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


d02babcfb681610c738aad78010f89c7192b6577
[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_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741
3742 void wxApp_CleanUp() {
3743 __wxPyCleanup();
3744 }
3745
3746
3747 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3748
3749
3750
3751
3752
3753 SWIGINTERNINLINE PyObject *
3754 SWIG_FromCharPtr(const char *cptr)
3755 {
3756 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3757 }
3758
3759
3760 #if 0 // #ifdef __WXMAC__
3761
3762 // A dummy class that raises an exception if used...
3763 class wxEventLoop
3764 {
3765 public:
3766 wxEventLoop() { wxPyRaiseNotImplemented(); }
3767 int Run() { return 0; }
3768 void Exit(int rc = 0) {}
3769 bool Pending() const { return false; }
3770 bool Dispatch() { return false; }
3771 bool IsRunning() const { return false; }
3772 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3773 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3774 };
3775
3776 #else
3777
3778 #include <wx/evtloop.h>
3779
3780 #endif
3781
3782
3783
3784 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3785 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3786 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3787 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3788 wxWindowList& list = self->GetChildren();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3792 #if wxUSE_HOTKEY
3793 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3794 #else
3795 return false;
3796 #endif
3797 }
3798 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3799
3800
3801
3802 return false;
3803
3804 }
3805 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3806 return wxPyGetWinHandle(self);
3807 }
3808 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3809 self->AssociateHandle((WXWidget)handle);
3810 }
3811
3812 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3813 return wxWindow::FindWindowById(id, parent);
3814 }
3815
3816 wxWindow* wxFindWindowByName( const wxString& name,
3817 const wxWindow *parent = NULL ) {
3818 return wxWindow::FindWindowByName(name, parent);
3819 }
3820
3821 wxWindow* wxFindWindowByLabel( const wxString& label,
3822 const wxWindow *parent = NULL ) {
3823 return wxWindow::FindWindowByLabel(label, parent);
3824 }
3825
3826
3827 #ifdef __WXMSW__
3828 #include <wx/msw/private.h> // to get wxGetWindowId
3829 #endif
3830
3831
3832 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3833 #ifdef __WXMSW__
3834 WXHWND hWnd = (WXHWND)_hWnd;
3835 long id = wxGetWindowId(hWnd);
3836 wxWindow* win = new wxWindow;
3837 if (parent)
3838 parent->AddChild(win);
3839 win->SetEventHandler(win);
3840 win->SetHWND(hWnd);
3841 win->SetId(id);
3842 win->SubclassWin(hWnd);
3843 win->AdoptAttributesFromHWND();
3844 win->SetupColours();
3845 return win;
3846 #else
3847 wxPyRaiseNotImplemented();
3848 return NULL;
3849 #endif
3850 }
3851
3852
3853 PyObject* GetTopLevelWindows() {
3854 return wxPy_ConvertList(&wxTopLevelWindows);
3855 }
3856
3857
3858 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3859 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3860 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3861
3862 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3863
3864
3865 SWIGINTERNINLINE int
3866 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3867 {
3868 unsigned long v;
3869 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3870 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3871 return res;
3872 }
3873
3874 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3875 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3876 wxMenuItemList& list = self->GetMenuItems();
3877 return wxPy_ConvertList(&list);
3878 }
3879 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3880 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3881 static const wxString wxPyControlNameStr(wxControlNameStr);
3882 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3883 if (clientData) {
3884 wxPyClientData* data = new wxPyClientData(clientData);
3885 return self->Append(item, data);
3886 } else
3887 return self->Append(item);
3888 }
3889 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3890 if (clientData) {
3891 wxPyClientData* data = new wxPyClientData(clientData);
3892 return self->Insert(item, pos, data);
3893 } else
3894 return self->Insert(item, pos);
3895 }
3896 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3897 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3898 if (data) {
3899 Py_INCREF(data->m_obj);
3900 return data->m_obj;
3901 } else {
3902 Py_INCREF(Py_None);
3903 return Py_None;
3904 }
3905 }
3906 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3907 wxPyClientData* data = new wxPyClientData(clientData);
3908 self->SetClientObject(n, data);
3909 }
3910
3911
3912 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3913 wxPyUserData* data = NULL;
3914 if ( userData ) {
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 data = new wxPyUserData(userData);
3917 wxPyEndBlockThreads(blocked);
3918 }
3919 return new wxSizerItem(window, proportion, flag, border, data);
3920 }
3921 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,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(width, height, proportion, flag, border, data);
3929 }
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,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(sizer, proportion, flag, border, data);
3938 }
3939
3940 #include <float.h>
3941
3942
3943 SWIGINTERN int
3944 SWIG_AsVal_float (PyObject * obj, float *val)
3945 {
3946 double v;
3947 int res = SWIG_AsVal_double (obj, &v);
3948 if (SWIG_IsOK(res)) {
3949 if ((v < -FLT_MAX || v > FLT_MAX)) {
3950 return SWIG_OverflowError;
3951 } else {
3952 if (val) *val = static_cast< float >(v);
3953 }
3954 }
3955 return res;
3956 }
3957
3958
3959 SWIGINTERNINLINE PyObject *
3960 SWIG_From_float (float value)
3961 {
3962 return SWIG_From_double (value);
3963 }
3964
3965 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3966 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3967 if (data) {
3968 Py_INCREF(data->m_obj);
3969 return data->m_obj;
3970 } else {
3971 Py_INCREF(Py_None);
3972 return Py_None;
3973 }
3974 }
3975 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3976 wxPyUserData* data = NULL;
3977 if ( userData ) {
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 data = new wxPyUserData(userData);
3980 wxPyEndBlockThreads(blocked);
3981 }
3982 self->SetUserData(data);
3983 }
3984
3985 // Figure out the type of the sizer item
3986
3987 struct wxPySizerItemInfo {
3988 wxPySizerItemInfo()
3989 : window(NULL), sizer(NULL), gotSize(false),
3990 size(wxDefaultSize), gotPos(false), pos(-1)
3991 {}
3992
3993 wxWindow* window;
3994 wxSizer* sizer;
3995 bool gotSize;
3996 wxSize size;
3997 bool gotPos;
3998 int pos;
3999 };
4000
4001 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4002
4003 wxPySizerItemInfo info;
4004 wxSize size;
4005 wxSize* sizePtr = &size;
4006
4007 // Find out what the type of the item is
4008 // try wxWindow
4009 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4010 PyErr_Clear();
4011 info.window = NULL;
4012
4013 // try wxSizer
4014 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4015 PyErr_Clear();
4016 info.sizer = NULL;
4017
4018 // try wxSize or (w,h)
4019 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4020 info.size = *sizePtr;
4021 info.gotSize = true;
4022 }
4023
4024 // or a single int
4025 if (checkIdx && PyInt_Check(item)) {
4026 info.pos = PyInt_AsLong(item);
4027 info.gotPos = true;
4028 }
4029 }
4030 }
4031
4032 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4033 // no expected type, figure out what kind of error message to generate
4034 if ( !checkSize && !checkIdx )
4035 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4036 else if ( checkSize && !checkIdx )
4037 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4038 else if ( !checkSize && checkIdx)
4039 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4040 else
4041 // can this one happen?
4042 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4043 }
4044
4045 return info;
4046 }
4047
4048 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4049 if (!self->GetClientObject())
4050 self->SetClientObject(new wxPyOORClientData(_self));
4051 }
4052 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4053
4054 wxPyUserData* data = NULL;
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4057 if ( userData && (info.window || info.sizer || info.gotSize) )
4058 data = new wxPyUserData(userData);
4059 if ( info.sizer )
4060 PyObject_SetAttrString(item,"thisown",Py_False);
4061 wxPyEndBlockThreads(blocked);
4062
4063 // Now call the real Add method if a valid item type was found
4064 if ( info.window )
4065 return self->Add(info.window, proportion, flag, border, data);
4066 else if ( info.sizer )
4067 return self->Add(info.sizer, proportion, flag, border, data);
4068 else if (info.gotSize)
4069 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4070 proportion, flag, border, data);
4071 else
4072 return NULL;
4073 }
4074 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4075
4076 wxPyUserData* data = NULL;
4077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4079 if ( userData && (info.window || info.sizer || info.gotSize) )
4080 data = new wxPyUserData(userData);
4081 if ( info.sizer )
4082 PyObject_SetAttrString(item,"thisown",Py_False);
4083 wxPyEndBlockThreads(blocked);
4084
4085 // Now call the real Insert method if a valid item type was found
4086 if ( info.window )
4087 return self->Insert(before, info.window, proportion, flag, border, data);
4088 else if ( info.sizer )
4089 return self->Insert(before, info.sizer, proportion, flag, border, data);
4090 else if (info.gotSize)
4091 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4092 proportion, flag, border, data);
4093 else
4094 return NULL;
4095 }
4096 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4097
4098 wxPyUserData* data = NULL;
4099 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4100 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4101 if ( userData && (info.window || info.sizer || info.gotSize) )
4102 data = new wxPyUserData(userData);
4103 if ( info.sizer )
4104 PyObject_SetAttrString(item,"thisown",Py_False);
4105 wxPyEndBlockThreads(blocked);
4106
4107 // Now call the real Prepend method if a valid item type was found
4108 if ( info.window )
4109 return self->Prepend(info.window, proportion, flag, border, data);
4110 else if ( info.sizer )
4111 return self->Prepend(info.sizer, proportion, flag, border, data);
4112 else if (info.gotSize)
4113 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4114 proportion, flag, border, data);
4115 else
4116 return NULL;
4117 }
4118 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4119 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4120 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4121 wxPyEndBlockThreads(blocked);
4122 if ( info.window )
4123 return self->Remove(info.window);
4124 else if ( info.sizer )
4125 return self->Remove(info.sizer);
4126 else if ( info.gotPos )
4127 return self->Remove(info.pos);
4128 else
4129 return false;
4130 }
4131 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4134 wxPyEndBlockThreads(blocked);
4135 if ( info.window )
4136 return self->Detach(info.window);
4137 else if ( info.sizer )
4138 return self->Detach(info.sizer);
4139 else if ( info.gotPos )
4140 return self->Detach(info.pos);
4141 else
4142 return false;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4145 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4146 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4147 wxPyEndBlockThreads(blocked);
4148 if ( info.window )
4149 return self->GetItem(info.window);
4150 else if ( info.sizer )
4151 return self->GetItem(info.sizer);
4152 else if ( info.gotPos )
4153 return self->GetItem(info.pos);
4154 else
4155 return NULL;
4156 }
4157 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4160 wxPyEndBlockThreads(blocked);
4161 if ( info.window )
4162 self->SetItemMinSize(info.window, size);
4163 else if ( info.sizer )
4164 self->SetItemMinSize(info.sizer, size);
4165 else if ( info.gotPos )
4166 self->SetItemMinSize(info.pos, size);
4167 }
4168 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4169 wxSizerItemList& list = self->GetChildren();
4170 return wxPy_ConvertList(&list);
4171 }
4172 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 return self->Show(info.window, show, recursive);
4178 else if ( info.sizer )
4179 return self->Show(info.sizer, show, recursive);
4180 else if ( info.gotPos )
4181 return self->Show(info.pos, show);
4182 else
4183 return false;
4184 }
4185 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 return self->IsShown(info.window);
4191 else if ( info.sizer )
4192 return self->IsShown(info.sizer);
4193 else if ( info.gotPos )
4194 return self->IsShown(info.pos);
4195 else
4196 return false;
4197 }
4198
4199 // See pyclasses.h
4200 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4201 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4202 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4203
4204
4205
4206
4207 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4208 {
4209 if (source == Py_None) {
4210 **obj = wxGBPosition(-1,-1);
4211 return true;
4212 }
4213 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4214 }
4215
4216 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4217 {
4218 if (source == Py_None) {
4219 **obj = wxGBSpan(-1,-1);
4220 return true;
4221 }
4222 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4223 }
4224
4225
4226 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4227 wxGBPosition temp, *obj = &temp;
4228 if ( other == Py_None ) return false;
4229 if ( ! wxGBPosition_helper(other, &obj) ) {
4230 PyErr_Clear();
4231 return false;
4232 }
4233 return self->operator==(*obj);
4234 }
4235 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4236 wxGBPosition temp, *obj = &temp;
4237 if ( other == Py_None ) return true;
4238 if ( ! wxGBPosition_helper(other, &obj)) {
4239 PyErr_Clear();
4240 return true;
4241 }
4242 return self->operator!=(*obj);
4243 }
4244 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4245 self->SetRow(row);
4246 self->SetCol(col);
4247 }
4248 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4249 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4250 PyObject* tup = PyTuple_New(2);
4251 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4252 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4253 wxPyEndBlockThreads(blocked);
4254 return tup;
4255 }
4256 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4257 wxGBSpan temp, *obj = &temp;
4258 if ( other == Py_None ) return false;
4259 if ( ! wxGBSpan_helper(other, &obj) ) {
4260 PyErr_Clear();
4261 return false;
4262 }
4263 return self->operator==(*obj);
4264 }
4265 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4266 wxGBSpan temp, *obj = &temp;
4267 if ( other == Py_None ) return true;
4268 if ( ! wxGBSpan_helper(other, &obj)) {
4269 PyErr_Clear();
4270 return true;
4271 }
4272 return self->operator!=(*obj);
4273 }
4274 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4275 self->SetRowspan(rowspan);
4276 self->SetColspan(colspan);
4277 }
4278 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 PyObject* tup = PyTuple_New(2);
4281 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4282 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4283 wxPyEndBlockThreads(blocked);
4284 return tup;
4285 }
4286 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4287 wxPyUserData* data = NULL;
4288 if ( userData ) {
4289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4290 data = new wxPyUserData(userData);
4291 wxPyEndBlockThreads(blocked);
4292 }
4293 return new wxGBSizerItem(window, pos, span, flag, border, data);
4294 }
4295 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4314 int row, col;
4315 self->GetEndPos(row, col);
4316 return wxGBPosition(row, col);
4317 }
4318 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4319
4320 wxPyUserData* data = NULL;
4321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4322 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4323 if ( userData && (info.window || info.sizer || info.gotSize) )
4324 data = new wxPyUserData(userData);
4325 if ( info.sizer )
4326 PyObject_SetAttrString(item,"thisown",Py_False);
4327 wxPyEndBlockThreads(blocked);
4328
4329 // Now call the real Add method if a valid item type was found
4330 if ( info.window )
4331 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4332 else if ( info.sizer )
4333 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4334 else if (info.gotSize)
4335 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4336 pos, span, flag, border, data);
4337 return NULL;
4338 }
4339
4340
4341 #ifdef __cplusplus
4342 extern "C" {
4343 #endif
4344 SWIGINTERN int EmptyString_set(PyObject *) {
4345 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4346 return 1;
4347 }
4348
4349
4350 SWIGINTERN PyObject *EmptyString_get(void) {
4351 PyObject *pyobj = 0;
4352
4353 {
4354 #if wxUSE_UNICODE
4355 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4356 #else
4357 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4358 #endif
4359 }
4360 return pyobj;
4361 }
4362
4363
4364 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4365 PyObject *resultobj = 0;
4366 wxObject *arg1 = (wxObject *) 0 ;
4367 wxString result;
4368 void *argp1 = 0 ;
4369 int res1 = 0 ;
4370 PyObject *swig_obj[1] ;
4371
4372 if (!args) SWIG_fail;
4373 swig_obj[0] = args;
4374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4375 if (!SWIG_IsOK(res1)) {
4376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4377 }
4378 arg1 = reinterpret_cast< wxObject * >(argp1);
4379 {
4380 PyThreadState* __tstate = wxPyBeginAllowThreads();
4381 result = wxObject_GetClassName(arg1);
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 {
4386 #if wxUSE_UNICODE
4387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4388 #else
4389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4390 #endif
4391 }
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxObject *arg1 = (wxObject *) 0 ;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 wxObject_Destroy(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 resultobj = SWIG_Py_Void();
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4426 PyObject *obj;
4427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4428 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4429 return SWIG_Py_Void();
4430 }
4431
4432 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4433 PyObject *resultobj = 0;
4434 wxSize *arg1 = (wxSize *) 0 ;
4435 int arg2 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 int val2 ;
4439 int ecode2 = 0 ;
4440 PyObject *swig_obj[2] ;
4441
4442 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4444 if (!SWIG_IsOK(res1)) {
4445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4446 }
4447 arg1 = reinterpret_cast< wxSize * >(argp1);
4448 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4449 if (!SWIG_IsOK(ecode2)) {
4450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4451 }
4452 arg2 = static_cast< int >(val2);
4453 if (arg1) (arg1)->x = arg2;
4454
4455 resultobj = SWIG_Py_Void();
4456 return resultobj;
4457 fail:
4458 return NULL;
4459 }
4460
4461
4462 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxSize *arg1 = (wxSize *) 0 ;
4465 int result;
4466 void *argp1 = 0 ;
4467 int res1 = 0 ;
4468 PyObject *swig_obj[1] ;
4469
4470 if (!args) SWIG_fail;
4471 swig_obj[0] = args;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 result = (int) ((arg1)->x);
4478 resultobj = SWIG_From_int(static_cast< int >(result));
4479 return resultobj;
4480 fail:
4481 return NULL;
4482 }
4483
4484
4485 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486 PyObject *resultobj = 0;
4487 wxSize *arg1 = (wxSize *) 0 ;
4488 int arg2 ;
4489 void *argp1 = 0 ;
4490 int res1 = 0 ;
4491 int val2 ;
4492 int ecode2 = 0 ;
4493 PyObject *swig_obj[2] ;
4494
4495 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4499 }
4500 arg1 = reinterpret_cast< wxSize * >(argp1);
4501 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4502 if (!SWIG_IsOK(ecode2)) {
4503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4504 }
4505 arg2 = static_cast< int >(val2);
4506 if (arg1) (arg1)->y = arg2;
4507
4508 resultobj = SWIG_Py_Void();
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxSize *arg1 = (wxSize *) 0 ;
4518 int result;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 PyObject *swig_obj[1] ;
4522
4523 if (!args) SWIG_fail;
4524 swig_obj[0] = args;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 result = (int) ((arg1)->y);
4531 resultobj = SWIG_From_int(static_cast< int >(result));
4532 return resultobj;
4533 fail:
4534 return NULL;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj = 0;
4540 int arg1 = (int) 0 ;
4541 int arg2 = (int) 0 ;
4542 wxSize *result = 0 ;
4543 int val1 ;
4544 int ecode1 = 0 ;
4545 int val2 ;
4546 int ecode2 = 0 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char * kwnames[] = {
4550 (char *) "w",(char *) "h", NULL
4551 };
4552
4553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4554 if (obj0) {
4555 ecode1 = SWIG_AsVal_int(obj0, &val1);
4556 if (!SWIG_IsOK(ecode1)) {
4557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4558 }
4559 arg1 = static_cast< int >(val1);
4560 }
4561 if (obj1) {
4562 ecode2 = SWIG_AsVal_int(obj1, &val2);
4563 if (!SWIG_IsOK(ecode2)) {
4564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4565 }
4566 arg2 = static_cast< int >(val2);
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (wxSize *)new wxSize(arg1,arg2);
4571 wxPyEndAllowThreads(__tstate);
4572 if (PyErr_Occurred()) SWIG_fail;
4573 }
4574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4575 return resultobj;
4576 fail:
4577 return NULL;
4578 }
4579
4580
4581 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *resultobj = 0;
4583 wxSize *arg1 = (wxSize *) 0 ;
4584 void *argp1 = 0 ;
4585 int res1 = 0 ;
4586 PyObject *swig_obj[1] ;
4587
4588 if (!args) SWIG_fail;
4589 swig_obj[0] = args;
4590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4591 if (!SWIG_IsOK(res1)) {
4592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4593 }
4594 arg1 = reinterpret_cast< wxSize * >(argp1);
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 delete arg1;
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 resultobj = SWIG_Py_Void();
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj = 0;
4611 wxSize *arg1 = (wxSize *) 0 ;
4612 PyObject *arg2 = (PyObject *) 0 ;
4613 bool result;
4614 void *argp1 = 0 ;
4615 int res1 = 0 ;
4616 PyObject * obj0 = 0 ;
4617 PyObject * obj1 = 0 ;
4618 char * kwnames[] = {
4619 (char *) "self",(char *) "other", NULL
4620 };
4621
4622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 arg2 = obj1;
4629 {
4630 result = (bool)wxSize___eq__(arg1,arg2);
4631 if (PyErr_Occurred()) SWIG_fail;
4632 }
4633 {
4634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4635 }
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___ne__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 wxSize *arg2 = 0 ;
4679 wxSize result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 wxSize temp2 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "self",(char *) "sz", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 {
4696 arg2 = &temp2;
4697 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4698 }
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = (arg1)->operator +((wxSize const &)*arg2);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj = 0;
4714 wxSize *arg1 = (wxSize *) 0 ;
4715 wxSize *arg2 = 0 ;
4716 wxSize result;
4717 void *argp1 = 0 ;
4718 int res1 = 0 ;
4719 wxSize temp2 ;
4720 PyObject * obj0 = 0 ;
4721 PyObject * obj1 = 0 ;
4722 char * kwnames[] = {
4723 (char *) "self",(char *) "sz", NULL
4724 };
4725
4726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4728 if (!SWIG_IsOK(res1)) {
4729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4730 }
4731 arg1 = reinterpret_cast< wxSize * >(argp1);
4732 {
4733 arg2 = &temp2;
4734 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4735 }
4736 {
4737 PyThreadState* __tstate = wxPyBeginAllowThreads();
4738 result = (arg1)->operator -((wxSize const &)*arg2);
4739 wxPyEndAllowThreads(__tstate);
4740 if (PyErr_Occurred()) SWIG_fail;
4741 }
4742 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 wxSize *arg1 = (wxSize *) 0 ;
4752 wxSize *arg2 = 0 ;
4753 void *argp1 = 0 ;
4754 int res1 = 0 ;
4755 wxSize temp2 ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 char * kwnames[] = {
4759 (char *) "self",(char *) "sz", NULL
4760 };
4761
4762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4764 if (!SWIG_IsOK(res1)) {
4765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4766 }
4767 arg1 = reinterpret_cast< wxSize * >(argp1);
4768 {
4769 arg2 = &temp2;
4770 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 (arg1)->IncTo((wxSize const &)*arg2);
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 resultobj = SWIG_Py_Void();
4779 return resultobj;
4780 fail:
4781 return NULL;
4782 }
4783
4784
4785 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4786 PyObject *resultobj = 0;
4787 wxSize *arg1 = (wxSize *) 0 ;
4788 wxSize *arg2 = 0 ;
4789 void *argp1 = 0 ;
4790 int res1 = 0 ;
4791 wxSize temp2 ;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char * kwnames[] = {
4795 (char *) "self",(char *) "sz", NULL
4796 };
4797
4798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4800 if (!SWIG_IsOK(res1)) {
4801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4802 }
4803 arg1 = reinterpret_cast< wxSize * >(argp1);
4804 {
4805 arg2 = &temp2;
4806 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4807 }
4808 {
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 (arg1)->DecTo((wxSize const &)*arg2);
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 resultobj = SWIG_Py_Void();
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj = 0;
4823 wxSize *arg1 = (wxSize *) 0 ;
4824 int arg2 ;
4825 int arg3 ;
4826 void *argp1 = 0 ;
4827 int res1 = 0 ;
4828 int val2 ;
4829 int ecode2 = 0 ;
4830 int val3 ;
4831 int ecode3 = 0 ;
4832 PyObject * obj0 = 0 ;
4833 PyObject * obj1 = 0 ;
4834 PyObject * obj2 = 0 ;
4835 char * kwnames[] = {
4836 (char *) "self",(char *) "w",(char *) "h", NULL
4837 };
4838
4839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4841 if (!SWIG_IsOK(res1)) {
4842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4843 }
4844 arg1 = reinterpret_cast< wxSize * >(argp1);
4845 ecode2 = SWIG_AsVal_int(obj1, &val2);
4846 if (!SWIG_IsOK(ecode2)) {
4847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4848 }
4849 arg2 = static_cast< int >(val2);
4850 ecode3 = SWIG_AsVal_int(obj2, &val3);
4851 if (!SWIG_IsOK(ecode3)) {
4852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4853 }
4854 arg3 = static_cast< int >(val3);
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 (arg1)->Set(arg2,arg3);
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 resultobj = SWIG_Py_Void();
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj = 0;
4870 wxSize *arg1 = (wxSize *) 0 ;
4871 int arg2 ;
4872 void *argp1 = 0 ;
4873 int res1 = 0 ;
4874 int val2 ;
4875 int ecode2 = 0 ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 char * kwnames[] = {
4879 (char *) "self",(char *) "w", NULL
4880 };
4881
4882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4884 if (!SWIG_IsOK(res1)) {
4885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4886 }
4887 arg1 = reinterpret_cast< wxSize * >(argp1);
4888 ecode2 = SWIG_AsVal_int(obj1, &val2);
4889 if (!SWIG_IsOK(ecode2)) {
4890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4891 }
4892 arg2 = static_cast< int >(val2);
4893 {
4894 PyThreadState* __tstate = wxPyBeginAllowThreads();
4895 (arg1)->SetWidth(arg2);
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = SWIG_Py_Void();
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj = 0;
4908 wxSize *arg1 = (wxSize *) 0 ;
4909 int arg2 ;
4910 void *argp1 = 0 ;
4911 int res1 = 0 ;
4912 int val2 ;
4913 int ecode2 = 0 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "h", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4922 if (!SWIG_IsOK(res1)) {
4923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4924 }
4925 arg1 = reinterpret_cast< wxSize * >(argp1);
4926 ecode2 = SWIG_AsVal_int(obj1, &val2);
4927 if (!SWIG_IsOK(ecode2)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4929 }
4930 arg2 = static_cast< int >(val2);
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 (arg1)->SetHeight(arg2);
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 resultobj = SWIG_Py_Void();
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4945 PyObject *resultobj = 0;
4946 wxSize *arg1 = (wxSize *) 0 ;
4947 int result;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 PyObject *swig_obj[1] ;
4951
4952 if (!args) SWIG_fail;
4953 swig_obj[0] = args;
4954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4955 if (!SWIG_IsOK(res1)) {
4956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4957 }
4958 arg1 = reinterpret_cast< wxSize * >(argp1);
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (int)((wxSize const *)arg1)->GetWidth();
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_From_int(static_cast< int >(result));
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4973 PyObject *resultobj = 0;
4974 wxSize *arg1 = (wxSize *) 0 ;
4975 int result;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 PyObject *swig_obj[1] ;
4979
4980 if (!args) SWIG_fail;
4981 swig_obj[0] = args;
4982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 {
4988 PyThreadState* __tstate = wxPyBeginAllowThreads();
4989 result = (int)((wxSize const *)arg1)->GetHeight();
4990 wxPyEndAllowThreads(__tstate);
4991 if (PyErr_Occurred()) SWIG_fail;
4992 }
4993 resultobj = SWIG_From_int(static_cast< int >(result));
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002 wxSize *arg1 = (wxSize *) 0 ;
5003 bool result;
5004 void *argp1 = 0 ;
5005 int res1 = 0 ;
5006 PyObject *swig_obj[1] ;
5007
5008 if (!args) SWIG_fail;
5009 swig_obj[0] = args;
5010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 {
5016 PyThreadState* __tstate = wxPyBeginAllowThreads();
5017 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 {
5022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5023 }
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj = 0;
5032 wxSize *arg1 = (wxSize *) 0 ;
5033 wxSize *arg2 = 0 ;
5034 void *argp1 = 0 ;
5035 int res1 = 0 ;
5036 wxSize temp2 ;
5037 PyObject * obj0 = 0 ;
5038 PyObject * obj1 = 0 ;
5039 char * kwnames[] = {
5040 (char *) "self",(char *) "size", NULL
5041 };
5042
5043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5045 if (!SWIG_IsOK(res1)) {
5046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5047 }
5048 arg1 = reinterpret_cast< wxSize * >(argp1);
5049 {
5050 arg2 = &temp2;
5051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5052 }
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 (arg1)->SetDefaults((wxSize const &)*arg2);
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 wxSize *arg1 = (wxSize *) 0 ;
5069 PyObject *result = 0 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 PyObject *swig_obj[1] ;
5073
5074 if (!args) SWIG_fail;
5075 swig_obj[0] = args;
5076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5077 if (!SWIG_IsOK(res1)) {
5078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5079 }
5080 arg1 = reinterpret_cast< wxSize * >(argp1);
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 result = (PyObject *)wxSize_Get(arg1);
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = result;
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095 PyObject *obj;
5096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5097 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5098 return SWIG_Py_Void();
5099 }
5100
5101 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102 return SWIG_Python_InitShadowInstance(args);
5103 }
5104
5105 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5108 double arg2 ;
5109 void *argp1 = 0 ;
5110 int res1 = 0 ;
5111 double val2 ;
5112 int ecode2 = 0 ;
5113 PyObject *swig_obj[2] ;
5114
5115 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5117 if (!SWIG_IsOK(res1)) {
5118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5119 }
5120 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5121 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5122 if (!SWIG_IsOK(ecode2)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5124 }
5125 arg2 = static_cast< double >(val2);
5126 if (arg1) (arg1)->x = arg2;
5127
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136 PyObject *resultobj = 0;
5137 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5138 double result;
5139 void *argp1 = 0 ;
5140 int res1 = 0 ;
5141 PyObject *swig_obj[1] ;
5142
5143 if (!args) SWIG_fail;
5144 swig_obj[0] = args;
5145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5146 if (!SWIG_IsOK(res1)) {
5147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5148 }
5149 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5150 result = (double) ((arg1)->x);
5151 resultobj = SWIG_From_double(static_cast< double >(result));
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5159 PyObject *resultobj = 0;
5160 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5161 double arg2 ;
5162 void *argp1 = 0 ;
5163 int res1 = 0 ;
5164 double val2 ;
5165 int ecode2 = 0 ;
5166 PyObject *swig_obj[2] ;
5167
5168 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5170 if (!SWIG_IsOK(res1)) {
5171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5172 }
5173 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5174 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5175 if (!SWIG_IsOK(ecode2)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5177 }
5178 arg2 = static_cast< double >(val2);
5179 if (arg1) (arg1)->y = arg2;
5180
5181 resultobj = SWIG_Py_Void();
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5189 PyObject *resultobj = 0;
5190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5191 double result;
5192 void *argp1 = 0 ;
5193 int res1 = 0 ;
5194 PyObject *swig_obj[1] ;
5195
5196 if (!args) SWIG_fail;
5197 swig_obj[0] = args;
5198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 result = (double) ((arg1)->y);
5204 resultobj = SWIG_From_double(static_cast< double >(result));
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj = 0;
5213 double arg1 = (double) 0.0 ;
5214 double arg2 = (double) 0.0 ;
5215 wxRealPoint *result = 0 ;
5216 double val1 ;
5217 int ecode1 = 0 ;
5218 double val2 ;
5219 int ecode2 = 0 ;
5220 PyObject * obj0 = 0 ;
5221 PyObject * obj1 = 0 ;
5222 char * kwnames[] = {
5223 (char *) "x",(char *) "y", NULL
5224 };
5225
5226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5227 if (obj0) {
5228 ecode1 = SWIG_AsVal_double(obj0, &val1);
5229 if (!SWIG_IsOK(ecode1)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5231 }
5232 arg1 = static_cast< double >(val1);
5233 }
5234 if (obj1) {
5235 ecode2 = SWIG_AsVal_double(obj1, &val2);
5236 if (!SWIG_IsOK(ecode2)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5238 }
5239 arg2 = static_cast< double >(val2);
5240 }
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 PyObject *swig_obj[1] ;
5260
5261 if (!args) SWIG_fail;
5262 swig_obj[0] = args;
5263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5264 if (!SWIG_IsOK(res1)) {
5265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5266 }
5267 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 delete arg1;
5271
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_Py_Void();
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj = 0;
5284 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5285 PyObject *arg2 = (PyObject *) 0 ;
5286 bool result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject * obj0 = 0 ;
5290 PyObject * obj1 = 0 ;
5291 char * kwnames[] = {
5292 (char *) "self",(char *) "other", NULL
5293 };
5294
5295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5297 if (!SWIG_IsOK(res1)) {
5298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5299 }
5300 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5301 arg2 = obj1;
5302 {
5303 result = (bool)wxRealPoint___eq__(arg1,arg2);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5308 }
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj = 0;
5317 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5318 PyObject *arg2 = (PyObject *) 0 ;
5319 bool result;
5320 void *argp1 = 0 ;
5321 int res1 = 0 ;
5322 PyObject * obj0 = 0 ;
5323 PyObject * obj1 = 0 ;
5324 char * kwnames[] = {
5325 (char *) "self",(char *) "other", NULL
5326 };
5327
5328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5330 if (!SWIG_IsOK(res1)) {
5331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5332 }
5333 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5334 arg2 = obj1;
5335 {
5336 result = (bool)wxRealPoint___ne__(arg1,arg2);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5341 }
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 wxRealPoint *arg2 = 0 ;
5352 wxRealPoint result;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 wxRealPoint temp2 ;
5356 PyObject * obj0 = 0 ;
5357 PyObject * obj1 = 0 ;
5358 char * kwnames[] = {
5359 (char *) "self",(char *) "pt", NULL
5360 };
5361
5362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5364 if (!SWIG_IsOK(res1)) {
5365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5366 }
5367 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5368 {
5369 arg2 = &temp2;
5370 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5371 }
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj = 0;
5387 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5388 wxRealPoint *arg2 = 0 ;
5389 wxRealPoint result;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 wxRealPoint temp2 ;
5393 PyObject * obj0 = 0 ;
5394 PyObject * obj1 = 0 ;
5395 char * kwnames[] = {
5396 (char *) "self",(char *) "pt", NULL
5397 };
5398
5399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5401 if (!SWIG_IsOK(res1)) {
5402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5403 }
5404 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5405 {
5406 arg2 = &temp2;
5407 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5408 }
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj = 0;
5424 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5425 double arg2 ;
5426 double arg3 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 double val2 ;
5430 int ecode2 = 0 ;
5431 double val3 ;
5432 int ecode3 = 0 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 PyObject * obj2 = 0 ;
5436 char * kwnames[] = {
5437 (char *) "self",(char *) "x",(char *) "y", NULL
5438 };
5439
5440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 ecode2 = SWIG_AsVal_double(obj1, &val2);
5447 if (!SWIG_IsOK(ecode2)) {
5448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5449 }
5450 arg2 = static_cast< double >(val2);
5451 ecode3 = SWIG_AsVal_double(obj2, &val3);
5452 if (!SWIG_IsOK(ecode3)) {
5453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5454 }
5455 arg3 = static_cast< double >(val3);
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 wxRealPoint_Set(arg1,arg2,arg3);
5459 wxPyEndAllowThreads(__tstate);
5460 if (PyErr_Occurred()) SWIG_fail;
5461 }
5462 resultobj = SWIG_Py_Void();
5463 return resultobj;
5464 fail:
5465 return NULL;
5466 }
5467
5468
5469 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5470 PyObject *resultobj = 0;
5471 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5472 PyObject *result = 0 ;
5473 void *argp1 = 0 ;
5474 int res1 = 0 ;
5475 PyObject *swig_obj[1] ;
5476
5477 if (!args) SWIG_fail;
5478 swig_obj[0] = args;
5479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5480 if (!SWIG_IsOK(res1)) {
5481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5482 }
5483 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (PyObject *)wxRealPoint_Get(arg1);
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = result;
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *obj;
5499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5500 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5501 return SWIG_Py_Void();
5502 }
5503
5504 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 return SWIG_Python_InitShadowInstance(args);
5506 }
5507
5508 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5509 PyObject *resultobj = 0;
5510 wxPoint *arg1 = (wxPoint *) 0 ;
5511 int arg2 ;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 int val2 ;
5515 int ecode2 = 0 ;
5516 PyObject *swig_obj[2] ;
5517
5518 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5520 if (!SWIG_IsOK(res1)) {
5521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5522 }
5523 arg1 = reinterpret_cast< wxPoint * >(argp1);
5524 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5525 if (!SWIG_IsOK(ecode2)) {
5526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5527 }
5528 arg2 = static_cast< int >(val2);
5529 if (arg1) (arg1)->x = arg2;
5530
5531 resultobj = SWIG_Py_Void();
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5539 PyObject *resultobj = 0;
5540 wxPoint *arg1 = (wxPoint *) 0 ;
5541 int result;
5542 void *argp1 = 0 ;
5543 int res1 = 0 ;
5544 PyObject *swig_obj[1] ;
5545
5546 if (!args) SWIG_fail;
5547 swig_obj[0] = args;
5548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5549 if (!SWIG_IsOK(res1)) {
5550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5551 }
5552 arg1 = reinterpret_cast< wxPoint * >(argp1);
5553 result = (int) ((arg1)->x);
5554 resultobj = SWIG_From_int(static_cast< int >(result));
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5562 PyObject *resultobj = 0;
5563 wxPoint *arg1 = (wxPoint *) 0 ;
5564 int arg2 ;
5565 void *argp1 = 0 ;
5566 int res1 = 0 ;
5567 int val2 ;
5568 int ecode2 = 0 ;
5569 PyObject *swig_obj[2] ;
5570
5571 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5573 if (!SWIG_IsOK(res1)) {
5574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5575 }
5576 arg1 = reinterpret_cast< wxPoint * >(argp1);
5577 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5578 if (!SWIG_IsOK(ecode2)) {
5579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5580 }
5581 arg2 = static_cast< int >(val2);
5582 if (arg1) (arg1)->y = arg2;
5583
5584 resultobj = SWIG_Py_Void();
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5592 PyObject *resultobj = 0;
5593 wxPoint *arg1 = (wxPoint *) 0 ;
5594 int result;
5595 void *argp1 = 0 ;
5596 int res1 = 0 ;
5597 PyObject *swig_obj[1] ;
5598
5599 if (!args) SWIG_fail;
5600 swig_obj[0] = args;
5601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5602 if (!SWIG_IsOK(res1)) {
5603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5604 }
5605 arg1 = reinterpret_cast< wxPoint * >(argp1);
5606 result = (int) ((arg1)->y);
5607 resultobj = SWIG_From_int(static_cast< int >(result));
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = 0;
5616 int arg1 = (int) 0 ;
5617 int arg2 = (int) 0 ;
5618 wxPoint *result = 0 ;
5619 int val1 ;
5620 int ecode1 = 0 ;
5621 int val2 ;
5622 int ecode2 = 0 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char * kwnames[] = {
5626 (char *) "x",(char *) "y", NULL
5627 };
5628
5629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5630 if (obj0) {
5631 ecode1 = SWIG_AsVal_int(obj0, &val1);
5632 if (!SWIG_IsOK(ecode1)) {
5633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5634 }
5635 arg1 = static_cast< int >(val1);
5636 }
5637 if (obj1) {
5638 ecode2 = SWIG_AsVal_int(obj1, &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5641 }
5642 arg2 = static_cast< int >(val2);
5643 }
5644 {
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 result = (wxPoint *)new wxPoint(arg1,arg2);
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 PyObject *swig_obj[1] ;
5663
5664 if (!args) SWIG_fail;
5665 swig_obj[0] = args;
5666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5667 if (!SWIG_IsOK(res1)) {
5668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5669 }
5670 arg1 = reinterpret_cast< wxPoint * >(argp1);
5671 {
5672 PyThreadState* __tstate = wxPyBeginAllowThreads();
5673 delete arg1;
5674
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 resultobj = SWIG_Py_Void();
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxPoint *arg1 = (wxPoint *) 0 ;
5688 PyObject *arg2 = (PyObject *) 0 ;
5689 bool result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 char * kwnames[] = {
5695 (char *) "self",(char *) "other", NULL
5696 };
5697
5698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5700 if (!SWIG_IsOK(res1)) {
5701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5702 }
5703 arg1 = reinterpret_cast< wxPoint * >(argp1);
5704 arg2 = obj1;
5705 {
5706 result = (bool)wxPoint___eq__(arg1,arg2);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 {
5710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5711 }
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj = 0;
5720 wxPoint *arg1 = (wxPoint *) 0 ;
5721 PyObject *arg2 = (PyObject *) 0 ;
5722 bool result;
5723 void *argp1 = 0 ;
5724 int res1 = 0 ;
5725 PyObject * obj0 = 0 ;
5726 PyObject * obj1 = 0 ;
5727 char * kwnames[] = {
5728 (char *) "self",(char *) "other", NULL
5729 };
5730
5731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5733 if (!SWIG_IsOK(res1)) {
5734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5735 }
5736 arg1 = reinterpret_cast< wxPoint * >(argp1);
5737 arg2 = obj1;
5738 {
5739 result = (bool)wxPoint___ne__(arg1,arg2);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 {
5743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5744 }
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5752 PyObject *resultobj = 0;
5753 wxPoint *arg1 = (wxPoint *) 0 ;
5754 wxPoint *arg2 = 0 ;
5755 wxPoint result;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 wxPoint temp2 ;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 char * kwnames[] = {
5762 (char *) "self",(char *) "pt", NULL
5763 };
5764
5765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5767 if (!SWIG_IsOK(res1)) {
5768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5769 }
5770 arg1 = reinterpret_cast< wxPoint * >(argp1);
5771 {
5772 arg2 = &temp2;
5773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 result = (arg1)->operator +((wxPoint const &)*arg2);
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5789 PyObject *resultobj = 0;
5790 wxPoint *arg1 = (wxPoint *) 0 ;
5791 wxPoint *arg2 = 0 ;
5792 wxPoint result;
5793 void *argp1 = 0 ;
5794 int res1 = 0 ;
5795 wxPoint temp2 ;
5796 PyObject * obj0 = 0 ;
5797 PyObject * obj1 = 0 ;
5798 char * kwnames[] = {
5799 (char *) "self",(char *) "pt", NULL
5800 };
5801
5802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5806 }
5807 arg1 = reinterpret_cast< wxPoint * >(argp1);
5808 {
5809 arg2 = &temp2;
5810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5811 }
5812 {
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 result = (arg1)->operator -((wxPoint const &)*arg2);
5815 wxPyEndAllowThreads(__tstate);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj = 0;
5827 wxPoint *arg1 = (wxPoint *) 0 ;
5828 wxPoint *arg2 = 0 ;
5829 wxPoint *result = 0 ;
5830 void *argp1 = 0 ;
5831 int res1 = 0 ;
5832 wxPoint temp2 ;
5833 PyObject * obj0 = 0 ;
5834 PyObject * obj1 = 0 ;
5835 char * kwnames[] = {
5836 (char *) "self",(char *) "pt", NULL
5837 };
5838
5839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5841 if (!SWIG_IsOK(res1)) {
5842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5843 }
5844 arg1 = reinterpret_cast< wxPoint * >(argp1);
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 {
5852 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5853 result = (wxPoint *) &_result_ref;
5854 }
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxPoint *arg1 = (wxPoint *) 0 ;
5868 wxPoint *arg2 = 0 ;
5869 wxPoint *result = 0 ;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 wxPoint temp2 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "self",(char *) "pt", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 arg2 = &temp2;
5887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5888 }
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 {
5892 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5893 result = (wxPoint *) &_result_ref;
5894 }
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 long arg2 ;
5909 long arg3 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 long val2 ;
5913 int ecode2 = 0 ;
5914 long val3 ;
5915 int ecode3 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 PyObject * obj2 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "self",(char *) "x",(char *) "y", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5925 if (!SWIG_IsOK(res1)) {
5926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5927 }
5928 arg1 = reinterpret_cast< wxPoint * >(argp1);
5929 ecode2 = SWIG_AsVal_long(obj1, &val2);
5930 if (!SWIG_IsOK(ecode2)) {
5931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5932 }
5933 arg2 = static_cast< long >(val2);
5934 ecode3 = SWIG_AsVal_long(obj2, &val3);
5935 if (!SWIG_IsOK(ecode3)) {
5936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5937 }
5938 arg3 = static_cast< long >(val3);
5939 {
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 wxPoint_Set(arg1,arg2,arg3);
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 resultobj = SWIG_Py_Void();
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5953 PyObject *resultobj = 0;
5954 wxPoint *arg1 = (wxPoint *) 0 ;
5955 PyObject *result = 0 ;
5956 void *argp1 = 0 ;
5957 int res1 = 0 ;
5958 PyObject *swig_obj[1] ;
5959
5960 if (!args) SWIG_fail;
5961 swig_obj[0] = args;
5962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5963 if (!SWIG_IsOK(res1)) {
5964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5965 }
5966 arg1 = reinterpret_cast< wxPoint * >(argp1);
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (PyObject *)wxPoint_Get(arg1);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = result;
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5981 PyObject *obj;
5982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5983 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5984 return SWIG_Py_Void();
5985 }
5986
5987 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5988 return SWIG_Python_InitShadowInstance(args);
5989 }
5990
5991 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj = 0;
5993 int arg1 = (int) 0 ;
5994 int arg2 = (int) 0 ;
5995 int arg3 = (int) 0 ;
5996 int arg4 = (int) 0 ;
5997 wxRect *result = 0 ;
5998 int val1 ;
5999 int ecode1 = 0 ;
6000 int val2 ;
6001 int ecode2 = 0 ;
6002 int val3 ;
6003 int ecode3 = 0 ;
6004 int val4 ;
6005 int ecode4 = 0 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 PyObject * obj2 = 0 ;
6009 PyObject * obj3 = 0 ;
6010 char * kwnames[] = {
6011 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6012 };
6013
6014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6015 if (obj0) {
6016 ecode1 = SWIG_AsVal_int(obj0, &val1);
6017 if (!SWIG_IsOK(ecode1)) {
6018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6019 }
6020 arg1 = static_cast< int >(val1);
6021 }
6022 if (obj1) {
6023 ecode2 = SWIG_AsVal_int(obj1, &val2);
6024 if (!SWIG_IsOK(ecode2)) {
6025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6026 }
6027 arg2 = static_cast< int >(val2);
6028 }
6029 if (obj2) {
6030 ecode3 = SWIG_AsVal_int(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6033 }
6034 arg3 = static_cast< int >(val3);
6035 }
6036 if (obj3) {
6037 ecode4 = SWIG_AsVal_int(obj3, &val4);
6038 if (!SWIG_IsOK(ecode4)) {
6039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6040 }
6041 arg4 = static_cast< int >(val4);
6042 }
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj = 0;
6058 wxPoint *arg1 = 0 ;
6059 wxPoint *arg2 = 0 ;
6060 wxRect *result = 0 ;
6061 wxPoint temp1 ;
6062 wxPoint temp2 ;
6063 PyObject * obj0 = 0 ;
6064 PyObject * obj1 = 0 ;
6065 char * kwnames[] = {
6066 (char *) "topLeft",(char *) "bottomRight", NULL
6067 };
6068
6069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6070 {
6071 arg1 = &temp1;
6072 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6073 }
6074 {
6075 arg2 = &temp2;
6076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6081 wxPyEndAllowThreads(__tstate);
6082 if (PyErr_Occurred()) SWIG_fail;
6083 }
6084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6085 return resultobj;
6086 fail:
6087 return NULL;
6088 }
6089
6090
6091 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6092 PyObject *resultobj = 0;
6093 wxPoint *arg1 = 0 ;
6094 wxSize *arg2 = 0 ;
6095 wxRect *result = 0 ;
6096 wxPoint temp1 ;
6097 wxSize temp2 ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 char * kwnames[] = {
6101 (char *) "pos",(char *) "size", NULL
6102 };
6103
6104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6105 {
6106 arg1 = &temp1;
6107 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6108 }
6109 {
6110 arg2 = &temp2;
6111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6112 }
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6120 return resultobj;
6121 fail:
6122 return NULL;
6123 }
6124
6125
6126 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj = 0;
6128 wxSize *arg1 = 0 ;
6129 wxRect *result = 0 ;
6130 wxSize temp1 ;
6131 PyObject * obj0 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "size", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6137 {
6138 arg1 = &temp1;
6139 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6140 }
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxRect *arg1 = (wxRect *) 0 ;
6157 void *argp1 = 0 ;
6158 int res1 = 0 ;
6159 PyObject *swig_obj[1] ;
6160
6161 if (!args) SWIG_fail;
6162 swig_obj[0] = args;
6163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6164 if (!SWIG_IsOK(res1)) {
6165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6166 }
6167 arg1 = reinterpret_cast< wxRect * >(argp1);
6168 {
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 delete arg1;
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_Py_Void();
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6183 PyObject *resultobj = 0;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 int result;
6186 void *argp1 = 0 ;
6187 int res1 = 0 ;
6188 PyObject *swig_obj[1] ;
6189
6190 if (!args) SWIG_fail;
6191 swig_obj[0] = args;
6192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6193 if (!SWIG_IsOK(res1)) {
6194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6195 }
6196 arg1 = reinterpret_cast< wxRect * >(argp1);
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 result = (int)((wxRect const *)arg1)->GetX();
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 resultobj = SWIG_From_int(static_cast< int >(result));
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj = 0;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int arg2 ;
6214 void *argp1 = 0 ;
6215 int res1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 char * kwnames[] = {
6221 (char *) "self",(char *) "x", NULL
6222 };
6223
6224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6226 if (!SWIG_IsOK(res1)) {
6227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6228 }
6229 arg1 = reinterpret_cast< wxRect * >(argp1);
6230 ecode2 = SWIG_AsVal_int(obj1, &val2);
6231 if (!SWIG_IsOK(ecode2)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6233 }
6234 arg2 = static_cast< int >(val2);
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 (arg1)->SetX(arg2);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_Py_Void();
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6249 PyObject *resultobj = 0;
6250 wxRect *arg1 = (wxRect *) 0 ;
6251 int result;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 result = (int)(arg1)->GetY();
6266 wxPyEndAllowThreads(__tstate);
6267 if (PyErr_Occurred()) SWIG_fail;
6268 }
6269 resultobj = SWIG_From_int(static_cast< int >(result));
6270 return resultobj;
6271 fail:
6272 return NULL;
6273 }
6274
6275
6276 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6277 PyObject *resultobj = 0;
6278 wxRect *arg1 = (wxRect *) 0 ;
6279 int arg2 ;
6280 void *argp1 = 0 ;
6281 int res1 = 0 ;
6282 int val2 ;
6283 int ecode2 = 0 ;
6284 PyObject * obj0 = 0 ;
6285 PyObject * obj1 = 0 ;
6286 char * kwnames[] = {
6287 (char *) "self",(char *) "y", NULL
6288 };
6289
6290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6292 if (!SWIG_IsOK(res1)) {
6293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6294 }
6295 arg1 = reinterpret_cast< wxRect * >(argp1);
6296 ecode2 = SWIG_AsVal_int(obj1, &val2);
6297 if (!SWIG_IsOK(ecode2)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6299 }
6300 arg2 = static_cast< int >(val2);
6301 {
6302 PyThreadState* __tstate = wxPyBeginAllowThreads();
6303 (arg1)->SetY(arg2);
6304 wxPyEndAllowThreads(__tstate);
6305 if (PyErr_Occurred()) SWIG_fail;
6306 }
6307 resultobj = SWIG_Py_Void();
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6315 PyObject *resultobj = 0;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int result;
6318 void *argp1 = 0 ;
6319 int res1 = 0 ;
6320 PyObject *swig_obj[1] ;
6321
6322 if (!args) SWIG_fail;
6323 swig_obj[0] = args;
6324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6325 if (!SWIG_IsOK(res1)) {
6326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6327 }
6328 arg1 = reinterpret_cast< wxRect * >(argp1);
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 result = (int)((wxRect const *)arg1)->GetWidth();
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_From_int(static_cast< int >(result));
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj = 0;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int arg2 ;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 int val2 ;
6349 int ecode2 = 0 ;
6350 PyObject * obj0 = 0 ;
6351 PyObject * obj1 = 0 ;
6352 char * kwnames[] = {
6353 (char *) "self",(char *) "w", NULL
6354 };
6355
6356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6358 if (!SWIG_IsOK(res1)) {
6359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6360 }
6361 arg1 = reinterpret_cast< wxRect * >(argp1);
6362 ecode2 = SWIG_AsVal_int(obj1, &val2);
6363 if (!SWIG_IsOK(ecode2)) {
6364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6365 }
6366 arg2 = static_cast< int >(val2);
6367 {
6368 PyThreadState* __tstate = wxPyBeginAllowThreads();
6369 (arg1)->SetWidth(arg2);
6370 wxPyEndAllowThreads(__tstate);
6371 if (PyErr_Occurred()) SWIG_fail;
6372 }
6373 resultobj = SWIG_Py_Void();
6374 return resultobj;
6375 fail:
6376 return NULL;
6377 }
6378
6379
6380 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6381 PyObject *resultobj = 0;
6382 wxRect *arg1 = (wxRect *) 0 ;
6383 int result;
6384 void *argp1 = 0 ;
6385 int res1 = 0 ;
6386 PyObject *swig_obj[1] ;
6387
6388 if (!args) SWIG_fail;
6389 swig_obj[0] = args;
6390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6391 if (!SWIG_IsOK(res1)) {
6392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6393 }
6394 arg1 = reinterpret_cast< wxRect * >(argp1);
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 result = (int)((wxRect const *)arg1)->GetHeight();
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 resultobj = SWIG_From_int(static_cast< int >(result));
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6409 PyObject *resultobj = 0;
6410 wxRect *arg1 = (wxRect *) 0 ;
6411 int arg2 ;
6412 void *argp1 = 0 ;
6413 int res1 = 0 ;
6414 int val2 ;
6415 int ecode2 = 0 ;
6416 PyObject * obj0 = 0 ;
6417 PyObject * obj1 = 0 ;
6418 char * kwnames[] = {
6419 (char *) "self",(char *) "h", NULL
6420 };
6421
6422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6424 if (!SWIG_IsOK(res1)) {
6425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6426 }
6427 arg1 = reinterpret_cast< wxRect * >(argp1);
6428 ecode2 = SWIG_AsVal_int(obj1, &val2);
6429 if (!SWIG_IsOK(ecode2)) {
6430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6431 }
6432 arg2 = static_cast< int >(val2);
6433 {
6434 PyThreadState* __tstate = wxPyBeginAllowThreads();
6435 (arg1)->SetHeight(arg2);
6436 wxPyEndAllowThreads(__tstate);
6437 if (PyErr_Occurred()) SWIG_fail;
6438 }
6439 resultobj = SWIG_Py_Void();
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6447 PyObject *resultobj = 0;
6448 wxRect *arg1 = (wxRect *) 0 ;
6449 wxPoint result;
6450 void *argp1 = 0 ;
6451 int res1 = 0 ;
6452 PyObject *swig_obj[1] ;
6453
6454 if (!args) SWIG_fail;
6455 swig_obj[0] = args;
6456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6457 if (!SWIG_IsOK(res1)) {
6458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6459 }
6460 arg1 = reinterpret_cast< wxRect * >(argp1);
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 result = ((wxRect const *)arg1)->GetPosition();
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj = 0;
6476 wxRect *arg1 = (wxRect *) 0 ;
6477 wxPoint *arg2 = 0 ;
6478 void *argp1 = 0 ;
6479 int res1 = 0 ;
6480 wxPoint temp2 ;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char * kwnames[] = {
6484 (char *) "self",(char *) "p", NULL
6485 };
6486
6487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6489 if (!SWIG_IsOK(res1)) {
6490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6491 }
6492 arg1 = reinterpret_cast< wxRect * >(argp1);
6493 {
6494 arg2 = &temp2;
6495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6496 }
6497 {
6498 PyThreadState* __tstate = wxPyBeginAllowThreads();
6499 (arg1)->SetPosition((wxPoint const &)*arg2);
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 resultobj = SWIG_Py_Void();
6504 return resultobj;
6505 fail:
6506 return NULL;
6507 }
6508
6509
6510 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6511 PyObject *resultobj = 0;
6512 wxRect *arg1 = (wxRect *) 0 ;
6513 wxSize result;
6514 void *argp1 = 0 ;
6515 int res1 = 0 ;
6516 PyObject *swig_obj[1] ;
6517
6518 if (!args) SWIG_fail;
6519 swig_obj[0] = args;
6520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6521 if (!SWIG_IsOK(res1)) {
6522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6523 }
6524 arg1 = reinterpret_cast< wxRect * >(argp1);
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 result = ((wxRect const *)arg1)->GetSize();
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 wxSize *arg2 = 0 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 wxSize temp2 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "s", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 arg2 = &temp2;
6559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6560 }
6561 {
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 (arg1)->SetSize((wxSize const &)*arg2);
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 bool result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (bool)((wxRect const *)arg1)->IsEmpty();
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 {
6596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6597 }
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6605 PyObject *resultobj = 0;
6606 wxRect *arg1 = (wxRect *) 0 ;
6607 wxPoint result;
6608 void *argp1 = 0 ;
6609 int res1 = 0 ;
6610 PyObject *swig_obj[1] ;
6611
6612 if (!args) SWIG_fail;
6613 swig_obj[0] = args;
6614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = ((wxRect const *)arg1)->GetTopLeft();
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxPoint *arg2 = 0 ;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 wxPoint temp2 ;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 char * kwnames[] = {
6642 (char *) "self",(char *) "p", NULL
6643 };
6644
6645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 arg2 = &temp2;
6653 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6654 }
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 resultobj = SWIG_Py_Void();
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 PyObject *resultobj = 0;
6670 wxRect *arg1 = (wxRect *) 0 ;
6671 wxPoint result;
6672 void *argp1 = 0 ;
6673 int res1 = 0 ;
6674 PyObject *swig_obj[1] ;
6675
6676 if (!args) SWIG_fail;
6677 swig_obj[0] = args;
6678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6679 if (!SWIG_IsOK(res1)) {
6680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6681 }
6682 arg1 = reinterpret_cast< wxRect * >(argp1);
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 result = ((wxRect const *)arg1)->GetBottomRight();
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxPoint *arg2 = 0 ;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 wxPoint temp2 ;
6703 PyObject * obj0 = 0 ;
6704 PyObject * obj1 = 0 ;
6705 char * kwnames[] = {
6706 (char *) "self",(char *) "p", NULL
6707 };
6708
6709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 arg2 = &temp2;
6717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6718 }
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_Py_Void();
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6733 PyObject *resultobj = 0;
6734 wxRect *arg1 = (wxRect *) 0 ;
6735 int result;
6736 void *argp1 = 0 ;
6737 int res1 = 0 ;
6738 PyObject *swig_obj[1] ;
6739
6740 if (!args) SWIG_fail;
6741 swig_obj[0] = args;
6742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 result = (int)((wxRect const *)arg1)->GetLeft();
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 resultobj = SWIG_From_int(static_cast< int >(result));
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxRect *arg1 = (wxRect *) 0 ;
6763 int result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxRect * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)((wxRect const *)arg1)->GetTop();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 wxRect *arg1 = (wxRect *) 0 ;
6791 int result;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 PyObject *swig_obj[1] ;
6795
6796 if (!args) SWIG_fail;
6797 swig_obj[0] = args;
6798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6801 }
6802 arg1 = reinterpret_cast< wxRect * >(argp1);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 result = (int)((wxRect const *)arg1)->GetBottom();
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_From_int(static_cast< int >(result));
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817 PyObject *resultobj = 0;
6818 wxRect *arg1 = (wxRect *) 0 ;
6819 int result;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject *swig_obj[1] ;
6823
6824 if (!args) SWIG_fail;
6825 swig_obj[0] = args;
6826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6827 if (!SWIG_IsOK(res1)) {
6828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6829 }
6830 arg1 = reinterpret_cast< wxRect * >(argp1);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (int)((wxRect const *)arg1)->GetRight();
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_From_int(static_cast< int >(result));
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 int arg2 ;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 int val2 ;
6851 int ecode2 = 0 ;
6852 PyObject * obj0 = 0 ;
6853 PyObject * obj1 = 0 ;
6854 char * kwnames[] = {
6855 (char *) "self",(char *) "left", NULL
6856 };
6857
6858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6860 if (!SWIG_IsOK(res1)) {
6861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6862 }
6863 arg1 = reinterpret_cast< wxRect * >(argp1);
6864 ecode2 = SWIG_AsVal_int(obj1, &val2);
6865 if (!SWIG_IsOK(ecode2)) {
6866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6867 }
6868 arg2 = static_cast< int >(val2);
6869 {
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 (arg1)->SetLeft(arg2);
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_Py_Void();
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj = 0;
6884 wxRect *arg1 = (wxRect *) 0 ;
6885 int arg2 ;
6886 void *argp1 = 0 ;
6887 int res1 = 0 ;
6888 int val2 ;
6889 int ecode2 = 0 ;
6890 PyObject * obj0 = 0 ;
6891 PyObject * obj1 = 0 ;
6892 char * kwnames[] = {
6893 (char *) "self",(char *) "right", NULL
6894 };
6895
6896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6898 if (!SWIG_IsOK(res1)) {
6899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6900 }
6901 arg1 = reinterpret_cast< wxRect * >(argp1);
6902 ecode2 = SWIG_AsVal_int(obj1, &val2);
6903 if (!SWIG_IsOK(ecode2)) {
6904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6905 }
6906 arg2 = static_cast< int >(val2);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 (arg1)->SetRight(arg2);
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_Py_Void();
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 int arg2 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 int val2 ;
6927 int ecode2 = 0 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "self",(char *) "top", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 ecode2 = SWIG_AsVal_int(obj1, &val2);
6941 if (!SWIG_IsOK(ecode2)) {
6942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6943 }
6944 arg2 = static_cast< int >(val2);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 (arg1)->SetTop(arg2);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_Py_Void();
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxRect *arg1 = (wxRect *) 0 ;
6961 int arg2 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 int val2 ;
6965 int ecode2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "bottom", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 ecode2 = SWIG_AsVal_int(obj1, &val2);
6979 if (!SWIG_IsOK(ecode2)) {
6980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6981 }
6982 arg2 = static_cast< int >(val2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetBottom(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int arg2 ;
7000 int arg3 ;
7001 wxRect *result = 0 ;
7002 void *argp1 = 0 ;
7003 int res1 = 0 ;
7004 int val2 ;
7005 int ecode2 = 0 ;
7006 int val3 ;
7007 int ecode3 = 0 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 PyObject * obj2 = 0 ;
7011 char * kwnames[] = {
7012 (char *) "self",(char *) "dx",(char *) "dy", NULL
7013 };
7014
7015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7017 if (!SWIG_IsOK(res1)) {
7018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7019 }
7020 arg1 = reinterpret_cast< wxRect * >(argp1);
7021 ecode2 = SWIG_AsVal_int(obj1, &val2);
7022 if (!SWIG_IsOK(ecode2)) {
7023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7024 }
7025 arg2 = static_cast< int >(val2);
7026 ecode3 = SWIG_AsVal_int(obj2, &val3);
7027 if (!SWIG_IsOK(ecode3)) {
7028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7029 }
7030 arg3 = static_cast< int >(val3);
7031 {
7032 PyThreadState* __tstate = wxPyBeginAllowThreads();
7033 {
7034 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7035 result = (wxRect *) &_result_ref;
7036 }
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7048 PyObject *resultobj = 0;
7049 wxRect *arg1 = (wxRect *) 0 ;
7050 int arg2 ;
7051 int arg3 ;
7052 wxRect *result = 0 ;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 int val2 ;
7056 int ecode2 = 0 ;
7057 int val3 ;
7058 int ecode3 = 0 ;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 PyObject * obj2 = 0 ;
7062 char * kwnames[] = {
7063 (char *) "self",(char *) "dx",(char *) "dy", NULL
7064 };
7065
7066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7068 if (!SWIG_IsOK(res1)) {
7069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7070 }
7071 arg1 = reinterpret_cast< wxRect * >(argp1);
7072 ecode2 = SWIG_AsVal_int(obj1, &val2);
7073 if (!SWIG_IsOK(ecode2)) {
7074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7075 }
7076 arg2 = static_cast< int >(val2);
7077 ecode3 = SWIG_AsVal_int(obj2, &val3);
7078 if (!SWIG_IsOK(ecode3)) {
7079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7080 }
7081 arg3 = static_cast< int >(val3);
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7086 result = (wxRect *) &_result_ref;
7087 }
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7099 PyObject *resultobj = 0;
7100 wxRect *arg1 = (wxRect *) 0 ;
7101 int arg2 ;
7102 int arg3 ;
7103 void *argp1 = 0 ;
7104 int res1 = 0 ;
7105 int val2 ;
7106 int ecode2 = 0 ;
7107 int val3 ;
7108 int ecode3 = 0 ;
7109 PyObject * obj0 = 0 ;
7110 PyObject * obj1 = 0 ;
7111 PyObject * obj2 = 0 ;
7112 char * kwnames[] = {
7113 (char *) "self",(char *) "dx",(char *) "dy", NULL
7114 };
7115
7116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7120 }
7121 arg1 = reinterpret_cast< wxRect * >(argp1);
7122 ecode2 = SWIG_AsVal_int(obj1, &val2);
7123 if (!SWIG_IsOK(ecode2)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7125 }
7126 arg2 = static_cast< int >(val2);
7127 ecode3 = SWIG_AsVal_int(obj2, &val3);
7128 if (!SWIG_IsOK(ecode3)) {
7129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7130 }
7131 arg3 = static_cast< int >(val3);
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 (arg1)->Offset(arg2,arg3);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_Py_Void();
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxRect *arg1 = (wxRect *) 0 ;
7148 wxPoint *arg2 = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 wxPoint temp2 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "self",(char *) "pt", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 {
7165 arg2 = &temp2;
7166 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7167 }
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 (arg1)->Offset((wxPoint const &)*arg2);
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 resultobj = SWIG_Py_Void();
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = 0;
7183 wxRect *arg1 = (wxRect *) 0 ;
7184 wxRect *arg2 = 0 ;
7185 wxRect result;
7186 void *argp1 = 0 ;
7187 int res1 = 0 ;
7188 wxRect temp2 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 char * kwnames[] = {
7192 (char *) "self",(char *) "rect", NULL
7193 };
7194
7195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7197 if (!SWIG_IsOK(res1)) {
7198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7199 }
7200 arg1 = reinterpret_cast< wxRect * >(argp1);
7201 {
7202 arg2 = &temp2;
7203 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7204 }
7205 {
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (arg1)->Intersect((wxRect const &)*arg2);
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj = 0;
7220 wxRect *arg1 = (wxRect *) 0 ;
7221 wxRect *arg2 = 0 ;
7222 wxRect result;
7223 void *argp1 = 0 ;
7224 int res1 = 0 ;
7225 wxRect temp2 ;
7226 PyObject * obj0 = 0 ;
7227 PyObject * obj1 = 0 ;
7228 char * kwnames[] = {
7229 (char *) "self",(char *) "rect", NULL
7230 };
7231
7232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7234 if (!SWIG_IsOK(res1)) {
7235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7236 }
7237 arg1 = reinterpret_cast< wxRect * >(argp1);
7238 {
7239 arg2 = &temp2;
7240 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7241 }
7242 {
7243 PyThreadState* __tstate = wxPyBeginAllowThreads();
7244 result = (arg1)->Union((wxRect const &)*arg2);
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = 0;
7257 wxRect *arg1 = (wxRect *) 0 ;
7258 wxRect *arg2 = 0 ;
7259 wxRect result;
7260 void *argp1 = 0 ;
7261 int res1 = 0 ;
7262 wxRect temp2 ;
7263 PyObject * obj0 = 0 ;
7264 PyObject * obj1 = 0 ;
7265 char * kwnames[] = {
7266 (char *) "self",(char *) "rect", NULL
7267 };
7268
7269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7271 if (!SWIG_IsOK(res1)) {
7272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7273 }
7274 arg1 = reinterpret_cast< wxRect * >(argp1);
7275 {
7276 arg2 = &temp2;
7277 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7278 }
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj = 0;
7294 wxRect *arg1 = (wxRect *) 0 ;
7295 wxRect *arg2 = 0 ;
7296 wxRect *result = 0 ;
7297 void *argp1 = 0 ;
7298 int res1 = 0 ;
7299 wxRect temp2 ;
7300 PyObject * obj0 = 0 ;
7301 PyObject * obj1 = 0 ;
7302 char * kwnames[] = {
7303 (char *) "self",(char *) "rect", NULL
7304 };
7305
7306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7308 if (!SWIG_IsOK(res1)) {
7309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7310 }
7311 arg1 = reinterpret_cast< wxRect * >(argp1);
7312 {
7313 arg2 = &temp2;
7314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7315 }
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 {
7319 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7320 result = (wxRect *) &_result_ref;
7321 }
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxRect *arg1 = (wxRect *) 0 ;
7335 PyObject *arg2 = (PyObject *) 0 ;
7336 bool result;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "other", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7349 }
7350 arg1 = reinterpret_cast< wxRect * >(argp1);
7351 arg2 = obj1;
7352 {
7353 result = (bool)wxRect___eq__(arg1,arg2);
7354 if (PyErr_Occurred()) SWIG_fail;
7355 }
7356 {
7357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7358 }
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj = 0;
7367 wxRect *arg1 = (wxRect *) 0 ;
7368 PyObject *arg2 = (PyObject *) 0 ;
7369 bool result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject * obj0 = 0 ;
7373 PyObject * obj1 = 0 ;
7374 char * kwnames[] = {
7375 (char *) "self",(char *) "other", NULL
7376 };
7377
7378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7380 if (!SWIG_IsOK(res1)) {
7381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7382 }
7383 arg1 = reinterpret_cast< wxRect * >(argp1);
7384 arg2 = obj1;
7385 {
7386 result = (bool)wxRect___ne__(arg1,arg2);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 {
7390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7391 }
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj = 0;
7400 wxRect *arg1 = (wxRect *) 0 ;
7401 int arg2 ;
7402 int arg3 ;
7403 bool result;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 int val2 ;
7407 int ecode2 = 0 ;
7408 int val3 ;
7409 int ecode3 = 0 ;
7410 PyObject * obj0 = 0 ;
7411 PyObject * obj1 = 0 ;
7412 PyObject * obj2 = 0 ;
7413 char * kwnames[] = {
7414 (char *) "self",(char *) "x",(char *) "y", NULL
7415 };
7416
7417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7419 if (!SWIG_IsOK(res1)) {
7420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7421 }
7422 arg1 = reinterpret_cast< wxRect * >(argp1);
7423 ecode2 = SWIG_AsVal_int(obj1, &val2);
7424 if (!SWIG_IsOK(ecode2)) {
7425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7426 }
7427 arg2 = static_cast< int >(val2);
7428 ecode3 = SWIG_AsVal_int(obj2, &val3);
7429 if (!SWIG_IsOK(ecode3)) {
7430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7431 }
7432 arg3 = static_cast< int >(val3);
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxPoint *arg2 = 0 ;
7452 bool result;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxPoint temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "pt", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj = 0;
7489 wxRect *arg1 = (wxRect *) 0 ;
7490 wxRect *arg2 = 0 ;
7491 bool result;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 wxRect temp2 ;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char * kwnames[] = {
7498 (char *) "self",(char *) "rect", NULL
7499 };
7500
7501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7503 if (!SWIG_IsOK(res1)) {
7504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7505 }
7506 arg1 = reinterpret_cast< wxRect * >(argp1);
7507 {
7508 arg2 = &temp2;
7509 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7510 }
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 {
7518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7519 }
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7527 PyObject *resultobj = 0;
7528 wxRect *arg1 = (wxRect *) 0 ;
7529 wxRect *arg2 = 0 ;
7530 int arg3 = (int) wxBOTH ;
7531 wxRect result;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 wxRect temp2 ;
7535 int val3 ;
7536 int ecode3 = 0 ;
7537 PyObject * obj0 = 0 ;
7538 PyObject * obj1 = 0 ;
7539 PyObject * obj2 = 0 ;
7540 char * kwnames[] = {
7541 (char *) "self",(char *) "r",(char *) "dir", NULL
7542 };
7543
7544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7546 if (!SWIG_IsOK(res1)) {
7547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7548 }
7549 arg1 = reinterpret_cast< wxRect * >(argp1);
7550 {
7551 arg2 = &temp2;
7552 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7553 }
7554 if (obj2) {
7555 ecode3 = SWIG_AsVal_int(obj2, &val3);
7556 if (!SWIG_IsOK(ecode3)) {
7557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7558 }
7559 arg3 = static_cast< int >(val3);
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 int arg2 ;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 int val2 ;
7581 int ecode2 = 0 ;
7582 PyObject *swig_obj[2] ;
7583
7584 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7586 if (!SWIG_IsOK(res1)) {
7587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7588 }
7589 arg1 = reinterpret_cast< wxRect * >(argp1);
7590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7591 if (!SWIG_IsOK(ecode2)) {
7592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7593 }
7594 arg2 = static_cast< int >(val2);
7595 if (arg1) (arg1)->x = arg2;
7596
7597 resultobj = SWIG_Py_Void();
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7605 PyObject *resultobj = 0;
7606 wxRect *arg1 = (wxRect *) 0 ;
7607 int result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 PyObject *swig_obj[1] ;
7611
7612 if (!args) SWIG_fail;
7613 swig_obj[0] = args;
7614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7617 }
7618 arg1 = reinterpret_cast< wxRect * >(argp1);
7619 result = (int) ((arg1)->x);
7620 resultobj = SWIG_From_int(static_cast< int >(result));
7621 return resultobj;
7622 fail:
7623 return NULL;
7624 }
7625
7626
7627 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7628 PyObject *resultobj = 0;
7629 wxRect *arg1 = (wxRect *) 0 ;
7630 int arg2 ;
7631 void *argp1 = 0 ;
7632 int res1 = 0 ;
7633 int val2 ;
7634 int ecode2 = 0 ;
7635 PyObject *swig_obj[2] ;
7636
7637 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7644 if (!SWIG_IsOK(ecode2)) {
7645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7646 }
7647 arg2 = static_cast< int >(val2);
7648 if (arg1) (arg1)->y = arg2;
7649
7650 resultobj = SWIG_Py_Void();
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7658 PyObject *resultobj = 0;
7659 wxRect *arg1 = (wxRect *) 0 ;
7660 int result;
7661 void *argp1 = 0 ;
7662 int res1 = 0 ;
7663 PyObject *swig_obj[1] ;
7664
7665 if (!args) SWIG_fail;
7666 swig_obj[0] = args;
7667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7668 if (!SWIG_IsOK(res1)) {
7669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7670 }
7671 arg1 = reinterpret_cast< wxRect * >(argp1);
7672 result = (int) ((arg1)->y);
7673 resultobj = SWIG_From_int(static_cast< int >(result));
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 int arg2 ;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 int val2 ;
7687 int ecode2 = 0 ;
7688 PyObject *swig_obj[2] ;
7689
7690 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7697 if (!SWIG_IsOK(ecode2)) {
7698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7699 }
7700 arg2 = static_cast< int >(val2);
7701 if (arg1) (arg1)->width = arg2;
7702
7703 resultobj = SWIG_Py_Void();
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7711 PyObject *resultobj = 0;
7712 wxRect *arg1 = (wxRect *) 0 ;
7713 int result;
7714 void *argp1 = 0 ;
7715 int res1 = 0 ;
7716 PyObject *swig_obj[1] ;
7717
7718 if (!args) SWIG_fail;
7719 swig_obj[0] = args;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 result = (int) ((arg1)->width);
7726 resultobj = SWIG_From_int(static_cast< int >(result));
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 PyObject *resultobj = 0;
7735 wxRect *arg1 = (wxRect *) 0 ;
7736 int arg2 ;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 int val2 ;
7740 int ecode2 = 0 ;
7741 PyObject *swig_obj[2] ;
7742
7743 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7750 if (!SWIG_IsOK(ecode2)) {
7751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7752 }
7753 arg2 = static_cast< int >(val2);
7754 if (arg1) (arg1)->height = arg2;
7755
7756 resultobj = SWIG_Py_Void();
7757 return resultobj;
7758 fail:
7759 return NULL;
7760 }
7761
7762
7763 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764 PyObject *resultobj = 0;
7765 wxRect *arg1 = (wxRect *) 0 ;
7766 int result;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 PyObject *swig_obj[1] ;
7770
7771 if (!args) SWIG_fail;
7772 swig_obj[0] = args;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 result = (int) ((arg1)->height);
7779 resultobj = SWIG_From_int(static_cast< int >(result));
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj = 0;
7788 wxRect *arg1 = (wxRect *) 0 ;
7789 int arg2 = (int) 0 ;
7790 int arg3 = (int) 0 ;
7791 int arg4 = (int) 0 ;
7792 int arg5 = (int) 0 ;
7793 void *argp1 = 0 ;
7794 int res1 = 0 ;
7795 int val2 ;
7796 int ecode2 = 0 ;
7797 int val3 ;
7798 int ecode3 = 0 ;
7799 int val4 ;
7800 int ecode4 = 0 ;
7801 int val5 ;
7802 int ecode5 = 0 ;
7803 PyObject * obj0 = 0 ;
7804 PyObject * obj1 = 0 ;
7805 PyObject * obj2 = 0 ;
7806 PyObject * obj3 = 0 ;
7807 PyObject * obj4 = 0 ;
7808 char * kwnames[] = {
7809 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7810 };
7811
7812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7814 if (!SWIG_IsOK(res1)) {
7815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7816 }
7817 arg1 = reinterpret_cast< wxRect * >(argp1);
7818 if (obj1) {
7819 ecode2 = SWIG_AsVal_int(obj1, &val2);
7820 if (!SWIG_IsOK(ecode2)) {
7821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7822 }
7823 arg2 = static_cast< int >(val2);
7824 }
7825 if (obj2) {
7826 ecode3 = SWIG_AsVal_int(obj2, &val3);
7827 if (!SWIG_IsOK(ecode3)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7829 }
7830 arg3 = static_cast< int >(val3);
7831 }
7832 if (obj3) {
7833 ecode4 = SWIG_AsVal_int(obj3, &val4);
7834 if (!SWIG_IsOK(ecode4)) {
7835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7836 }
7837 arg4 = static_cast< int >(val4);
7838 }
7839 if (obj4) {
7840 ecode5 = SWIG_AsVal_int(obj4, &val5);
7841 if (!SWIG_IsOK(ecode5)) {
7842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7843 }
7844 arg5 = static_cast< int >(val5);
7845 }
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 resultobj = SWIG_Py_Void();
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7860 PyObject *resultobj = 0;
7861 wxRect *arg1 = (wxRect *) 0 ;
7862 PyObject *result = 0 ;
7863 void *argp1 = 0 ;
7864 int res1 = 0 ;
7865 PyObject *swig_obj[1] ;
7866
7867 if (!args) SWIG_fail;
7868 swig_obj[0] = args;
7869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7870 if (!SWIG_IsOK(res1)) {
7871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7872 }
7873 arg1 = reinterpret_cast< wxRect * >(argp1);
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 result = (PyObject *)wxRect_Get(arg1);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = result;
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7888 PyObject *obj;
7889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7890 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7891 return SWIG_Py_Void();
7892 }
7893
7894 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7895 return SWIG_Python_InitShadowInstance(args);
7896 }
7897
7898 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 wxRect *arg2 = (wxRect *) 0 ;
7902 PyObject *result = 0 ;
7903 void *argp1 = 0 ;
7904 int res1 = 0 ;
7905 void *argp2 = 0 ;
7906 int res2 = 0 ;
7907 PyObject * obj0 = 0 ;
7908 PyObject * obj1 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "r1",(char *) "r2", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7917 }
7918 arg1 = reinterpret_cast< wxRect * >(argp1);
7919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7920 if (!SWIG_IsOK(res2)) {
7921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7922 }
7923 arg2 = reinterpret_cast< wxRect * >(argp2);
7924 {
7925 if (!wxPyCheckForApp()) SWIG_fail;
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (PyObject *)wxIntersectRect(arg1,arg2);
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 resultobj = result;
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7939 PyObject *resultobj = 0;
7940 double arg1 = (double) 0.0 ;
7941 double arg2 = (double) 0.0 ;
7942 wxPoint2D *result = 0 ;
7943 double val1 ;
7944 int ecode1 = 0 ;
7945 double val2 ;
7946 int ecode2 = 0 ;
7947 PyObject * obj0 = 0 ;
7948 PyObject * obj1 = 0 ;
7949 char * kwnames[] = {
7950 (char *) "x",(char *) "y", NULL
7951 };
7952
7953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7954 if (obj0) {
7955 ecode1 = SWIG_AsVal_double(obj0, &val1);
7956 if (!SWIG_IsOK(ecode1)) {
7957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7958 }
7959 arg1 = static_cast< double >(val1);
7960 }
7961 if (obj1) {
7962 ecode2 = SWIG_AsVal_double(obj1, &val2);
7963 if (!SWIG_IsOK(ecode2)) {
7964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7965 }
7966 arg2 = static_cast< double >(val2);
7967 }
7968 {
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7982 PyObject *resultobj = 0;
7983 wxPoint2D *arg1 = 0 ;
7984 wxPoint2D *result = 0 ;
7985 wxPoint2D temp1 ;
7986 PyObject * obj0 = 0 ;
7987 char * kwnames[] = {
7988 (char *) "pt", NULL
7989 };
7990
7991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7992 {
7993 arg1 = &temp1;
7994 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7995 }
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxPoint *arg1 = 0 ;
8012 wxPoint2D *result = 0 ;
8013 wxPoint temp1 ;
8014 PyObject * obj0 = 0 ;
8015 char * kwnames[] = {
8016 (char *) "pt", NULL
8017 };
8018
8019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8020 {
8021 arg1 = &temp1;
8022 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8023 }
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8040 int *arg2 = (int *) 0 ;
8041 int *arg3 = (int *) 0 ;
8042 void *argp1 = 0 ;
8043 int res1 = 0 ;
8044 int temp2 ;
8045 int res2 = SWIG_TMPOBJ ;
8046 int temp3 ;
8047 int res3 = SWIG_TMPOBJ ;
8048 PyObject *swig_obj[1] ;
8049
8050 arg2 = &temp2;
8051 arg3 = &temp3;
8052 if (!args) SWIG_fail;
8053 swig_obj[0] = args;
8054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8057 }
8058 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = SWIG_Py_Void();
8066 if (SWIG_IsTmpObj(res2)) {
8067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8068 } else {
8069 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8071 }
8072 if (SWIG_IsTmpObj(res3)) {
8073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8074 } else {
8075 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8077 }
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8085 PyObject *resultobj = 0;
8086 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8087 int *arg2 = (int *) 0 ;
8088 int *arg3 = (int *) 0 ;
8089 void *argp1 = 0 ;
8090 int res1 = 0 ;
8091 int temp2 ;
8092 int res2 = SWIG_TMPOBJ ;
8093 int temp3 ;
8094 int res3 = SWIG_TMPOBJ ;
8095 PyObject *swig_obj[1] ;
8096
8097 arg2 = &temp2;
8098 arg3 = &temp3;
8099 if (!args) SWIG_fail;
8100 swig_obj[0] = args;
8101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8104 }
8105 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_Py_Void();
8113 if (SWIG_IsTmpObj(res2)) {
8114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8115 } else {
8116 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8118 }
8119 if (SWIG_IsTmpObj(res3)) {
8120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8121 } else {
8122 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8124 }
8125 return resultobj;
8126 fail:
8127 return NULL;
8128 }
8129
8130
8131 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8132 PyObject *resultobj = 0;
8133 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8134 double result;
8135 void *argp1 = 0 ;
8136 int res1 = 0 ;
8137 PyObject *swig_obj[1] ;
8138
8139 if (!args) SWIG_fail;
8140 swig_obj[0] = args;
8141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8144 }
8145 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 resultobj = SWIG_From_double(static_cast< double >(result));
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8162 double result;
8163 void *argp1 = 0 ;
8164 int res1 = 0 ;
8165 PyObject *swig_obj[1] ;
8166
8167 if (!args) SWIG_fail;
8168 swig_obj[0] = args;
8169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8172 }
8173 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8174 {
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 resultobj = SWIG_From_double(static_cast< double >(result));
8181 return resultobj;
8182 fail:
8183 return NULL;
8184 }
8185
8186
8187 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8188 PyObject *resultobj = 0;
8189 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8190 double arg2 ;
8191 void *argp1 = 0 ;
8192 int res1 = 0 ;
8193 double val2 ;
8194 int ecode2 = 0 ;
8195 PyObject * obj0 = 0 ;
8196 PyObject * obj1 = 0 ;
8197 char * kwnames[] = {
8198 (char *) "self",(char *) "length", NULL
8199 };
8200
8201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8205 }
8206 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8207 ecode2 = SWIG_AsVal_double(obj1, &val2);
8208 if (!SWIG_IsOK(ecode2)) {
8209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8210 }
8211 arg2 = static_cast< double >(val2);
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 (arg1)->SetVectorLength(arg2);
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 resultobj = SWIG_Py_Void();
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj = 0;
8227 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8228 double arg2 ;
8229 void *argp1 = 0 ;
8230 int res1 = 0 ;
8231 double val2 ;
8232 int ecode2 = 0 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 char * kwnames[] = {
8236 (char *) "self",(char *) "degrees", NULL
8237 };
8238
8239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8241 if (!SWIG_IsOK(res1)) {
8242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8243 }
8244 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8245 ecode2 = SWIG_AsVal_double(obj1, &val2);
8246 if (!SWIG_IsOK(ecode2)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8248 }
8249 arg2 = static_cast< double >(val2);
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 (arg1)->SetVectorAngle(arg2);
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_Py_Void();
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8266 wxPoint2D *arg2 = 0 ;
8267 double result;
8268 void *argp1 = 0 ;
8269 int res1 = 0 ;
8270 wxPoint2D temp2 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "pt", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8281 }
8282 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8283 {
8284 arg2 = &temp2;
8285 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8286 }
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_From_double(static_cast< double >(result));
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 wxPoint2D *arg2 = 0 ;
8304 double result;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 wxPoint2D temp2 ;
8308 PyObject * obj0 = 0 ;
8309 PyObject * obj1 = 0 ;
8310 char * kwnames[] = {
8311 (char *) "self",(char *) "pt", NULL
8312 };
8313
8314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8316 if (!SWIG_IsOK(res1)) {
8317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8318 }
8319 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8320 {
8321 arg2 = &temp2;
8322 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8327 wxPyEndAllowThreads(__tstate);
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 resultobj = SWIG_From_double(static_cast< double >(result));
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = 0;
8339 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8340 wxPoint2D *arg2 = 0 ;
8341 double result;
8342 void *argp1 = 0 ;
8343 int res1 = 0 ;
8344 wxPoint2D temp2 ;
8345 PyObject * obj0 = 0 ;
8346 PyObject * obj1 = 0 ;
8347 char * kwnames[] = {
8348 (char *) "self",(char *) "vec", NULL
8349 };
8350
8351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8353 if (!SWIG_IsOK(res1)) {
8354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8355 }
8356 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8357 {
8358 arg2 = &temp2;
8359 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8360 }
8361 {
8362 PyThreadState* __tstate = wxPyBeginAllowThreads();
8363 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8364 wxPyEndAllowThreads(__tstate);
8365 if (PyErr_Occurred()) SWIG_fail;
8366 }
8367 resultobj = SWIG_From_double(static_cast< double >(result));
8368 return resultobj;
8369 fail:
8370 return NULL;
8371 }
8372
8373
8374 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8375 PyObject *resultobj = 0;
8376 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8377 wxPoint2D *arg2 = 0 ;
8378 double result;
8379 void *argp1 = 0 ;
8380 int res1 = 0 ;
8381 wxPoint2D temp2 ;
8382 PyObject * obj0 = 0 ;
8383 PyObject * obj1 = 0 ;
8384 char * kwnames[] = {
8385 (char *) "self",(char *) "vec", NULL
8386 };
8387
8388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8390 if (!SWIG_IsOK(res1)) {
8391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8392 }
8393 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8394 {
8395 arg2 = &temp2;
8396 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8397 }
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_From_double(static_cast< double >(result));
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 PyObject *resultobj = 0;
8413 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8414 wxPoint2D result;
8415 void *argp1 = 0 ;
8416 int res1 = 0 ;
8417 PyObject *swig_obj[1] ;
8418
8419 if (!args) SWIG_fail;
8420 swig_obj[0] = args;
8421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8422 if (!SWIG_IsOK(res1)) {
8423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8424 }
8425 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (arg1)->operator -();
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj = 0;
8441 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8442 wxPoint2D *arg2 = 0 ;
8443 wxPoint2D *result = 0 ;
8444 void *argp1 = 0 ;
8445 int res1 = 0 ;
8446 wxPoint2D temp2 ;
8447 PyObject * obj0 = 0 ;
8448 PyObject * obj1 = 0 ;
8449 char * kwnames[] = {
8450 (char *) "self",(char *) "pt", NULL
8451 };
8452
8453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8455 if (!SWIG_IsOK(res1)) {
8456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8457 }
8458 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8459 {
8460 arg2 = &temp2;
8461 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8462 }
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 {
8466 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8467 result = (wxPoint2D *) &_result_ref;
8468 }
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj = 0;
8481 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8482 wxPoint2D *arg2 = 0 ;
8483 wxPoint2D *result = 0 ;
8484 void *argp1 = 0 ;
8485 int res1 = 0 ;
8486 wxPoint2D temp2 ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char * kwnames[] = {
8490 (char *) "self",(char *) "pt", NULL
8491 };
8492
8493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8495 if (!SWIG_IsOK(res1)) {
8496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8497 }
8498 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8499 {
8500 arg2 = &temp2;
8501 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8502 }
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 {
8506 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8507 result = (wxPoint2D *) &_result_ref;
8508 }
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8522 wxPoint2D *arg2 = 0 ;
8523 wxPoint2D *result = 0 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 wxPoint2D temp2 ;
8527 PyObject * obj0 = 0 ;
8528 PyObject * obj1 = 0 ;
8529 char * kwnames[] = {
8530 (char *) "self",(char *) "pt", NULL
8531 };
8532
8533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8537 }
8538 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8539 {
8540 arg2 = &temp2;
8541 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8542 }
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 {
8546 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8547 result = (wxPoint2D *) &_result_ref;
8548 }
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj = 0;
8561 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8562 wxPoint2D *arg2 = 0 ;
8563 wxPoint2D *result = 0 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 wxPoint2D temp2 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "pt", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8577 }
8578 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8579 {
8580 arg2 = &temp2;
8581 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8582 }
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 {
8586 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8587 result = (wxPoint2D *) &_result_ref;
8588 }
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 PyObject *arg2 = (PyObject *) 0 ;
8603 bool result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "other", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 arg2 = obj1;
8619 {
8620 result = (bool)wxPoint2D___eq__(arg1,arg2);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 {
8624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8625 }
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj = 0;
8634 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8635 PyObject *arg2 = (PyObject *) 0 ;
8636 bool result;
8637 void *argp1 = 0 ;
8638 int res1 = 0 ;
8639 PyObject * obj0 = 0 ;
8640 PyObject * obj1 = 0 ;
8641 char * kwnames[] = {
8642 (char *) "self",(char *) "other", NULL
8643 };
8644
8645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8649 }
8650 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8651 arg2 = obj1;
8652 {
8653 result = (bool)wxPoint2D___ne__(arg1,arg2);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 {
8657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8658 }
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666 PyObject *resultobj = 0;
8667 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8668 double arg2 ;
8669 void *argp1 = 0 ;
8670 int res1 = 0 ;
8671 double val2 ;
8672 int ecode2 = 0 ;
8673 PyObject *swig_obj[2] ;
8674
8675 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8682 if (!SWIG_IsOK(ecode2)) {
8683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8684 }
8685 arg2 = static_cast< double >(val2);
8686 if (arg1) (arg1)->m_x = arg2;
8687
8688 resultobj = SWIG_Py_Void();
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 double result;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 PyObject *swig_obj[1] ;
8702
8703 if (!args) SWIG_fail;
8704 swig_obj[0] = args;
8705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8706 if (!SWIG_IsOK(res1)) {
8707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8708 }
8709 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8710 result = (double) ((arg1)->m_x);
8711 resultobj = SWIG_From_double(static_cast< double >(result));
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 double arg2 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 double val2 ;
8725 int ecode2 = 0 ;
8726 PyObject *swig_obj[2] ;
8727
8728 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8730 if (!SWIG_IsOK(res1)) {
8731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8732 }
8733 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8734 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8735 if (!SWIG_IsOK(ecode2)) {
8736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8737 }
8738 arg2 = static_cast< double >(val2);
8739 if (arg1) (arg1)->m_y = arg2;
8740
8741 resultobj = SWIG_Py_Void();
8742 return resultobj;
8743 fail:
8744 return NULL;
8745 }
8746
8747
8748 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8749 PyObject *resultobj = 0;
8750 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8751 double result;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 PyObject *swig_obj[1] ;
8755
8756 if (!args) SWIG_fail;
8757 swig_obj[0] = args;
8758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8759 if (!SWIG_IsOK(res1)) {
8760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8761 }
8762 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8763 result = (double) ((arg1)->m_y);
8764 resultobj = SWIG_From_double(static_cast< double >(result));
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 double arg2 = (double) 0 ;
8775 double arg3 = (double) 0 ;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 double val2 ;
8779 int ecode2 = 0 ;
8780 double val3 ;
8781 int ecode3 = 0 ;
8782 PyObject * obj0 = 0 ;
8783 PyObject * obj1 = 0 ;
8784 PyObject * obj2 = 0 ;
8785 char * kwnames[] = {
8786 (char *) "self",(char *) "x",(char *) "y", NULL
8787 };
8788
8789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8791 if (!SWIG_IsOK(res1)) {
8792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8793 }
8794 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8795 if (obj1) {
8796 ecode2 = SWIG_AsVal_double(obj1, &val2);
8797 if (!SWIG_IsOK(ecode2)) {
8798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8799 }
8800 arg2 = static_cast< double >(val2);
8801 }
8802 if (obj2) {
8803 ecode3 = SWIG_AsVal_double(obj2, &val3);
8804 if (!SWIG_IsOK(ecode3)) {
8805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8806 }
8807 arg3 = static_cast< double >(val3);
8808 }
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 wxPoint2D_Set(arg1,arg2,arg3);
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 resultobj = SWIG_Py_Void();
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8823 PyObject *resultobj = 0;
8824 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8825 PyObject *result = 0 ;
8826 void *argp1 = 0 ;
8827 int res1 = 0 ;
8828 PyObject *swig_obj[1] ;
8829
8830 if (!args) SWIG_fail;
8831 swig_obj[0] = args;
8832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8833 if (!SWIG_IsOK(res1)) {
8834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8835 }
8836 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 result = (PyObject *)wxPoint2D_Get(arg1);
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = result;
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851 PyObject *obj;
8852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8853 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8854 return SWIG_Py_Void();
8855 }
8856
8857 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8858 return SWIG_Python_InitShadowInstance(args);
8859 }
8860
8861 SWIGINTERN int DefaultPosition_set(PyObject *) {
8862 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8863 return 1;
8864 }
8865
8866
8867 SWIGINTERN PyObject *DefaultPosition_get(void) {
8868 PyObject *pyobj = 0;
8869
8870 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8871 return pyobj;
8872 }
8873
8874
8875 SWIGINTERN int DefaultSize_set(PyObject *) {
8876 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8877 return 1;
8878 }
8879
8880
8881 SWIGINTERN PyObject *DefaultSize_get(void) {
8882 PyObject *pyobj = 0;
8883
8884 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8885 return pyobj;
8886 }
8887
8888
8889 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8890 PyObject *resultobj = 0;
8891 PyObject *arg1 = (PyObject *) 0 ;
8892 wxPyInputStream *result = 0 ;
8893 PyObject * obj0 = 0 ;
8894 char * kwnames[] = {
8895 (char *) "p", NULL
8896 };
8897
8898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8899 arg1 = obj0;
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8914 PyObject *resultobj = 0;
8915 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 PyObject *swig_obj[1] ;
8919
8920 if (!args) SWIG_fail;
8921 swig_obj[0] = args;
8922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8923 if (!SWIG_IsOK(res1)) {
8924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8925 }
8926 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 delete arg1;
8930
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_Py_Void();
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 PyObject *swig_obj[1] ;
8947
8948 if (!args) SWIG_fail;
8949 swig_obj[0] = args;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->close();
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8980 }
8981 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 (arg1)->flush();
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8998 bool result;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9008 }
9009 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 result = (bool)(arg1)->eof();
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 {
9017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9018 }
9019 return resultobj;
9020 fail:
9021 return NULL;
9022 }
9023
9024
9025 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj = 0;
9027 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9028 int arg2 = (int) -1 ;
9029 PyObject *result = 0 ;
9030 void *argp1 = 0 ;
9031 int res1 = 0 ;
9032 int val2 ;
9033 int ecode2 = 0 ;
9034 PyObject * obj0 = 0 ;
9035 PyObject * obj1 = 0 ;
9036 char * kwnames[] = {
9037 (char *) "self",(char *) "size", NULL
9038 };
9039
9040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9046 if (obj1) {
9047 ecode2 = SWIG_AsVal_int(obj1, &val2);
9048 if (!SWIG_IsOK(ecode2)) {
9049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9050 }
9051 arg2 = static_cast< int >(val2);
9052 }
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (PyObject *)(arg1)->read(arg2);
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = result;
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj = 0;
9068 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9069 int arg2 = (int) -1 ;
9070 PyObject *result = 0 ;
9071 void *argp1 = 0 ;
9072 int res1 = 0 ;
9073 int val2 ;
9074 int ecode2 = 0 ;
9075 PyObject * obj0 = 0 ;
9076 PyObject * obj1 = 0 ;
9077 char * kwnames[] = {
9078 (char *) "self",(char *) "size", NULL
9079 };
9080
9081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9087 if (obj1) {
9088 ecode2 = SWIG_AsVal_int(obj1, &val2);
9089 if (!SWIG_IsOK(ecode2)) {
9090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9091 }
9092 arg2 = static_cast< int >(val2);
9093 }
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 result = (PyObject *)(arg1)->readline(arg2);
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 resultobj = result;
9101 return resultobj;
9102 fail:
9103 return NULL;
9104 }
9105
9106
9107 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9108 PyObject *resultobj = 0;
9109 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9110 int arg2 = (int) -1 ;
9111 PyObject *result = 0 ;
9112 void *argp1 = 0 ;
9113 int res1 = 0 ;
9114 int val2 ;
9115 int ecode2 = 0 ;
9116 PyObject * obj0 = 0 ;
9117 PyObject * obj1 = 0 ;
9118 char * kwnames[] = {
9119 (char *) "self",(char *) "sizehint", NULL
9120 };
9121
9122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9124 if (!SWIG_IsOK(res1)) {
9125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9126 }
9127 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9128 if (obj1) {
9129 ecode2 = SWIG_AsVal_int(obj1, &val2);
9130 if (!SWIG_IsOK(ecode2)) {
9131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9132 }
9133 arg2 = static_cast< int >(val2);
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 result = (PyObject *)(arg1)->readlines(arg2);
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = result;
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj = 0;
9150 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9151 int arg2 ;
9152 int arg3 = (int) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 int val2 ;
9156 int ecode2 = 0 ;
9157 int val3 ;
9158 int ecode3 = 0 ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 PyObject * obj2 = 0 ;
9162 char * kwnames[] = {
9163 (char *) "self",(char *) "offset",(char *) "whence", NULL
9164 };
9165
9166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9168 if (!SWIG_IsOK(res1)) {
9169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9170 }
9171 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9172 ecode2 = SWIG_AsVal_int(obj1, &val2);
9173 if (!SWIG_IsOK(ecode2)) {
9174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9175 }
9176 arg2 = static_cast< int >(val2);
9177 if (obj2) {
9178 ecode3 = SWIG_AsVal_int(obj2, &val3);
9179 if (!SWIG_IsOK(ecode3)) {
9180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9181 }
9182 arg3 = static_cast< int >(val3);
9183 }
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 (arg1)->seek(arg2,arg3);
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 resultobj = SWIG_Py_Void();
9191 return resultobj;
9192 fail:
9193 return NULL;
9194 }
9195
9196
9197 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9198 PyObject *resultobj = 0;
9199 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9200 int result;
9201 void *argp1 = 0 ;
9202 int res1 = 0 ;
9203 PyObject *swig_obj[1] ;
9204
9205 if (!args) SWIG_fail;
9206 swig_obj[0] = args;
9207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9208 if (!SWIG_IsOK(res1)) {
9209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9210 }
9211 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (int)(arg1)->tell();
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_From_int(static_cast< int >(result));
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 char result;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9238 }
9239 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (char)(arg1)->Peek();
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_From_char(static_cast< char >(result));
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9256 char result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9266 }
9267 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 result = (char)(arg1)->GetC();
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_From_char(static_cast< char >(result));
9275 return resultobj;
9276 fail:
9277 return NULL;
9278 }
9279
9280
9281 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 PyObject *resultobj = 0;
9283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9284 size_t result;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9294 }
9295 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 result = (size_t)(arg1)->LastRead();
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310 PyObject *resultobj = 0;
9311 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9312 bool result;
9313 void *argp1 = 0 ;
9314 int res1 = 0 ;
9315 PyObject *swig_obj[1] ;
9316
9317 if (!args) SWIG_fail;
9318 swig_obj[0] = args;
9319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (bool)(arg1)->CanRead();
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 {
9331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9332 }
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9342 bool result;
9343 void *argp1 = 0 ;
9344 int res1 = 0 ;
9345 PyObject *swig_obj[1] ;
9346
9347 if (!args) SWIG_fail;
9348 swig_obj[0] = args;
9349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9350 if (!SWIG_IsOK(res1)) {
9351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9352 }
9353 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (bool)(arg1)->Eof();
9357 wxPyEndAllowThreads(__tstate);
9358 if (PyErr_Occurred()) SWIG_fail;
9359 }
9360 {
9361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9362 }
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = 0;
9371 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9372 char arg2 ;
9373 bool result;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 char val2 ;
9377 int ecode2 = 0 ;
9378 PyObject * obj0 = 0 ;
9379 PyObject * obj1 = 0 ;
9380 char * kwnames[] = {
9381 (char *) "self",(char *) "c", NULL
9382 };
9383
9384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9388 }
9389 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9390 ecode2 = SWIG_AsVal_char(obj1, &val2);
9391 if (!SWIG_IsOK(ecode2)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9393 }
9394 arg2 = static_cast< char >(val2);
9395 {
9396 PyThreadState* __tstate = wxPyBeginAllowThreads();
9397 result = (bool)(arg1)->Ungetch(arg2);
9398 wxPyEndAllowThreads(__tstate);
9399 if (PyErr_Occurred()) SWIG_fail;
9400 }
9401 {
9402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9403 }
9404 return resultobj;
9405 fail:
9406 return NULL;
9407 }
9408
9409
9410 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj = 0;
9412 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9413 long arg2 ;
9414 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9415 long result;
9416 void *argp1 = 0 ;
9417 int res1 = 0 ;
9418 long val2 ;
9419 int ecode2 = 0 ;
9420 int val3 ;
9421 int ecode3 = 0 ;
9422 PyObject * obj0 = 0 ;
9423 PyObject * obj1 = 0 ;
9424 PyObject * obj2 = 0 ;
9425 char * kwnames[] = {
9426 (char *) "self",(char *) "pos",(char *) "mode", NULL
9427 };
9428
9429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9431 if (!SWIG_IsOK(res1)) {
9432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9433 }
9434 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9435 ecode2 = SWIG_AsVal_long(obj1, &val2);
9436 if (!SWIG_IsOK(ecode2)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9438 }
9439 arg2 = static_cast< long >(val2);
9440 if (obj2) {
9441 ecode3 = SWIG_AsVal_int(obj2, &val3);
9442 if (!SWIG_IsOK(ecode3)) {
9443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9444 }
9445 arg3 = static_cast< wxSeekMode >(val3);
9446 }
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 result = (long)(arg1)->SeekI(arg2,arg3);
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_From_long(static_cast< long >(result));
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 PyObject *resultobj = 0;
9462 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9463 long result;
9464 void *argp1 = 0 ;
9465 int res1 = 0 ;
9466 PyObject *swig_obj[1] ;
9467
9468 if (!args) SWIG_fail;
9469 swig_obj[0] = args;
9470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9471 if (!SWIG_IsOK(res1)) {
9472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9473 }
9474 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (long)(arg1)->TellI();
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_From_long(static_cast< long >(result));
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *obj;
9490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9491 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9492 return SWIG_Py_Void();
9493 }
9494
9495 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9496 return SWIG_Python_InitShadowInstance(args);
9497 }
9498
9499 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj = 0;
9501 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9502 PyObject *arg2 = (PyObject *) 0 ;
9503 void *argp1 = 0 ;
9504 int res1 = 0 ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 char * kwnames[] = {
9508 (char *) "self",(char *) "obj", NULL
9509 };
9510
9511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9513 if (!SWIG_IsOK(res1)) {
9514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9515 }
9516 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9517 arg2 = obj1;
9518 {
9519 PyThreadState* __tstate = wxPyBeginAllowThreads();
9520 wxOutputStream_write(arg1,arg2);
9521 wxPyEndAllowThreads(__tstate);
9522 if (PyErr_Occurred()) SWIG_fail;
9523 }
9524 resultobj = SWIG_Py_Void();
9525 return resultobj;
9526 fail:
9527 return NULL;
9528 }
9529
9530
9531 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9532 PyObject *resultobj = 0;
9533 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9534 size_t result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 PyObject *swig_obj[1] ;
9538
9539 if (!args) SWIG_fail;
9540 swig_obj[0] = args;
9541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9544 }
9545 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *obj;
9561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9562 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9563 return SWIG_Py_Void();
9564 }
9565
9566 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj = 0;
9568 wxInputStream *arg1 = (wxInputStream *) 0 ;
9569 wxString *arg2 = 0 ;
9570 wxString *arg3 = 0 ;
9571 wxString *arg4 = 0 ;
9572 wxDateTime arg5 ;
9573 wxFSFile *result = 0 ;
9574 wxPyInputStream *temp1 ;
9575 bool temp2 = false ;
9576 bool temp3 = false ;
9577 bool temp4 = false ;
9578 void *argp5 ;
9579 int res5 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 PyObject * obj2 = 0 ;
9583 PyObject * obj3 = 0 ;
9584 PyObject * obj4 = 0 ;
9585 char * kwnames[] = {
9586 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9587 };
9588
9589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9590 {
9591 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9592 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9593 } else {
9594 PyErr_Clear(); // clear the failure of the wxPyConvert above
9595 arg1 = wxPyCBInputStream_create(obj0, true);
9596 if (arg1 == NULL) {
9597 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9598 SWIG_fail;
9599 }
9600 }
9601 }
9602 {
9603 arg2 = wxString_in_helper(obj1);
9604 if (arg2 == NULL) SWIG_fail;
9605 temp2 = true;
9606 }
9607 {
9608 arg3 = wxString_in_helper(obj2);
9609 if (arg3 == NULL) SWIG_fail;
9610 temp3 = true;
9611 }
9612 {
9613 arg4 = wxString_in_helper(obj3);
9614 if (arg4 == NULL) SWIG_fail;
9615 temp4 = true;
9616 }
9617 {
9618 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9619 if (!SWIG_IsOK(res5)) {
9620 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9621 }
9622 if (!argp5) {
9623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9624 } else {
9625 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9626 arg5 = *temp;
9627 if (SWIG_IsNewObj(res5)) delete temp;
9628 }
9629 }
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 {
9637 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9638 }
9639 {
9640 if (temp2)
9641 delete arg2;
9642 }
9643 {
9644 if (temp3)
9645 delete arg3;
9646 }
9647 {
9648 if (temp4)
9649 delete arg4;
9650 }
9651 return resultobj;
9652 fail:
9653 {
9654 if (temp2)
9655 delete arg2;
9656 }
9657 {
9658 if (temp3)
9659 delete arg3;
9660 }
9661 {
9662 if (temp4)
9663 delete arg4;
9664 }
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9670 PyObject *resultobj = 0;
9671 wxFSFile *arg1 = (wxFSFile *) 0 ;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9681 }
9682 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 delete arg1;
9686
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 PyObject *resultobj = 0;
9699 wxFSFile *arg1 = (wxFSFile *) 0 ;
9700 wxInputStream *result = 0 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 PyObject *swig_obj[1] ;
9704
9705 if (!args) SWIG_fail;
9706 swig_obj[0] = args;
9707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9708 if (!SWIG_IsOK(res1)) {
9709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9710 }
9711 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 result = (wxInputStream *)(arg1)->GetStream();
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 {
9719 wxPyInputStream * _ptr = NULL;
9720
9721 if (result) {
9722 _ptr = new wxPyInputStream(result);
9723 }
9724 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9725 }
9726 return resultobj;
9727 fail:
9728 return NULL;
9729 }
9730
9731
9732 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9733 PyObject *resultobj = 0;
9734 wxFSFile *arg1 = (wxFSFile *) 0 ;
9735 wxString *result = 0 ;
9736 void *argp1 = 0 ;
9737 int res1 = 0 ;
9738 PyObject *swig_obj[1] ;
9739
9740 if (!args) SWIG_fail;
9741 swig_obj[0] = args;
9742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9743 if (!SWIG_IsOK(res1)) {
9744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9745 }
9746 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 {
9750 wxString const &_result_ref = (arg1)->GetMimeType();
9751 result = (wxString *) &_result_ref;
9752 }
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 {
9757 #if wxUSE_UNICODE
9758 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9759 #else
9760 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9761 #endif
9762 }
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9770 PyObject *resultobj = 0;
9771 wxFSFile *arg1 = (wxFSFile *) 0 ;
9772 wxString *result = 0 ;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 PyObject *swig_obj[1] ;
9776
9777 if (!args) SWIG_fail;
9778 swig_obj[0] = args;
9779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9780 if (!SWIG_IsOK(res1)) {
9781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9782 }
9783 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 {
9787 wxString const &_result_ref = (arg1)->GetLocation();
9788 result = (wxString *) &_result_ref;
9789 }
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 #if wxUSE_UNICODE
9795 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9796 #else
9797 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9798 #endif
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 wxFSFile *arg1 = (wxFSFile *) 0 ;
9809 wxString *result = 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 PyObject *swig_obj[1] ;
9813
9814 if (!args) SWIG_fail;
9815 swig_obj[0] = args;
9816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9819 }
9820 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 {
9824 wxString const &_result_ref = (arg1)->GetAnchor();
9825 result = (wxString *) &_result_ref;
9826 }
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *resultobj = 0;
9845 wxFSFile *arg1 = (wxFSFile *) 0 ;
9846 wxDateTime result;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 PyObject *swig_obj[1] ;
9850
9851 if (!args) SWIG_fail;
9852 swig_obj[0] = args;
9853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9856 }
9857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 result = (arg1)->GetModificationTime();
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 PyObject *obj;
9873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9874 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9875 return SWIG_Py_Void();
9876 }
9877
9878 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9879 return SWIG_Python_InitShadowInstance(args);
9880 }
9881
9882 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 PyObject *resultobj = 0;
9884 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 PyObject *swig_obj[1] ;
9888
9889 if (!args) SWIG_fail;
9890 swig_obj[0] = args;
9891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9894 }
9895 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 delete arg1;
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 resultobj = SWIG_Py_Void();
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9911 PyObject *obj;
9912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9913 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9914 return SWIG_Py_Void();
9915 }
9916
9917 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxPyFileSystemHandler *result = 0 ;
9920
9921 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj = 0;
9937 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9938 PyObject *arg2 = (PyObject *) 0 ;
9939 PyObject *arg3 = (PyObject *) 0 ;
9940 void *argp1 = 0 ;
9941 int res1 = 0 ;
9942 PyObject * obj0 = 0 ;
9943 PyObject * obj1 = 0 ;
9944 PyObject * obj2 = 0 ;
9945 char * kwnames[] = {
9946 (char *) "self",(char *) "self",(char *) "_class", NULL
9947 };
9948
9949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9953 }
9954 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9955 arg2 = obj1;
9956 arg3 = obj2;
9957 {
9958 PyThreadState* __tstate = wxPyBeginAllowThreads();
9959 (arg1)->_setCallbackInfo(arg2,arg3);
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_Py_Void();
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = 0;
9972 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9973 wxString *arg2 = 0 ;
9974 bool result;
9975 void *argp1 = 0 ;
9976 int res1 = 0 ;
9977 bool temp2 = false ;
9978 PyObject * obj0 = 0 ;
9979 PyObject * obj1 = 0 ;
9980 char * kwnames[] = {
9981 (char *) "self",(char *) "location", NULL
9982 };
9983
9984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9988 }
9989 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9990 {
9991 arg2 = wxString_in_helper(obj1);
9992 if (arg2 == NULL) SWIG_fail;
9993 temp2 = true;
9994 }
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 {
10002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10003 }
10004 {
10005 if (temp2)
10006 delete arg2;
10007 }
10008 return resultobj;
10009 fail:
10010 {
10011 if (temp2)
10012 delete arg2;
10013 }
10014 return NULL;
10015 }
10016
10017
10018 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10019 PyObject *resultobj = 0;
10020 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10021 wxFileSystem *arg2 = 0 ;
10022 wxString *arg3 = 0 ;
10023 wxFSFile *result = 0 ;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 void *argp2 = 0 ;
10027 int res2 = 0 ;
10028 bool temp3 = false ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 PyObject * obj2 = 0 ;
10032 char * kwnames[] = {
10033 (char *) "self",(char *) "fs",(char *) "location", NULL
10034 };
10035
10036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10040 }
10041 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10043 if (!SWIG_IsOK(res2)) {
10044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10045 }
10046 if (!argp2) {
10047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10048 }
10049 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10050 {
10051 arg3 = wxString_in_helper(obj2);
10052 if (arg3 == NULL) SWIG_fail;
10053 temp3 = true;
10054 }
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 {
10062 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10063 }
10064 {
10065 if (temp3)
10066 delete arg3;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp3)
10072 delete arg3;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj = 0;
10080 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10081 wxString *arg2 = 0 ;
10082 int arg3 = (int) 0 ;
10083 wxString result;
10084 void *argp1 = 0 ;
10085 int res1 = 0 ;
10086 bool temp2 = false ;
10087 int val3 ;
10088 int ecode3 = 0 ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 PyObject * obj2 = 0 ;
10092 char * kwnames[] = {
10093 (char *) "self",(char *) "spec",(char *) "flags", NULL
10094 };
10095
10096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10098 if (!SWIG_IsOK(res1)) {
10099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10100 }
10101 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10102 {
10103 arg2 = wxString_in_helper(obj1);
10104 if (arg2 == NULL) SWIG_fail;
10105 temp2 = true;
10106 }
10107 if (obj2) {
10108 ecode3 = SWIG_AsVal_int(obj2, &val3);
10109 if (!SWIG_IsOK(ecode3)) {
10110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10111 }
10112 arg3 = static_cast< int >(val3);
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 #if wxUSE_UNICODE
10122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10123 #else
10124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10125 #endif
10126 }
10127 {
10128 if (temp2)
10129 delete arg2;
10130 }
10131 return resultobj;
10132 fail:
10133 {
10134 if (temp2)
10135 delete arg2;
10136 }
10137 return NULL;
10138 }
10139
10140
10141 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142 PyObject *resultobj = 0;
10143 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10144 wxString result;
10145 void *argp1 = 0 ;
10146 int res1 = 0 ;
10147 PyObject *swig_obj[1] ;
10148
10149 if (!args) SWIG_fail;
10150 swig_obj[0] = args;
10151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10152 if (!SWIG_IsOK(res1)) {
10153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10154 }
10155 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (arg1)->FindNext();
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 {
10163 #if wxUSE_UNICODE
10164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10165 #else
10166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10167 #endif
10168 }
10169 return resultobj;
10170 fail:
10171 return NULL;
10172 }
10173
10174
10175 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj = 0;
10177 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10178 wxString *arg2 = 0 ;
10179 wxString result;
10180 void *argp1 = 0 ;
10181 int res1 = 0 ;
10182 bool temp2 = false ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char * kwnames[] = {
10186 (char *) "self",(char *) "location", NULL
10187 };
10188
10189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10193 }
10194 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10195 {
10196 arg2 = wxString_in_helper(obj1);
10197 if (arg2 == NULL) SWIG_fail;
10198 temp2 = true;
10199 }
10200 {
10201 PyThreadState* __tstate = wxPyBeginAllowThreads();
10202 result = (arg1)->GetProtocol((wxString const &)*arg2);
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 {
10207 #if wxUSE_UNICODE
10208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10209 #else
10210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10211 #endif
10212 }
10213 {
10214 if (temp2)
10215 delete arg2;
10216 }
10217 return resultobj;
10218 fail:
10219 {
10220 if (temp2)
10221 delete arg2;
10222 }
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10230 wxString *arg2 = 0 ;
10231 wxString result;
10232 void *argp1 = 0 ;
10233 int res1 = 0 ;
10234 bool temp2 = false ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "location", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10245 }
10246 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10247 {
10248 arg2 = wxString_in_helper(obj1);
10249 if (arg2 == NULL) SWIG_fail;
10250 temp2 = true;
10251 }
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 {
10259 #if wxUSE_UNICODE
10260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10261 #else
10262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10263 #endif
10264 }
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return resultobj;
10270 fail:
10271 {
10272 if (temp2)
10273 delete arg2;
10274 }
10275 return NULL;
10276 }
10277
10278
10279 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10280 PyObject *resultobj = 0;
10281 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10282 wxString *arg2 = 0 ;
10283 wxString result;
10284 void *argp1 = 0 ;
10285 int res1 = 0 ;
10286 bool temp2 = false ;
10287 PyObject * obj0 = 0 ;
10288 PyObject * obj1 = 0 ;
10289 char * kwnames[] = {
10290 (char *) "self",(char *) "location", NULL
10291 };
10292
10293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10295 if (!SWIG_IsOK(res1)) {
10296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10297 }
10298 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10299 {
10300 arg2 = wxString_in_helper(obj1);
10301 if (arg2 == NULL) SWIG_fail;
10302 temp2 = true;
10303 }
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (arg1)->GetAnchor((wxString const &)*arg2);
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 {
10311 #if wxUSE_UNICODE
10312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10313 #else
10314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10315 #endif
10316 }
10317 {
10318 if (temp2)
10319 delete arg2;
10320 }
10321 return resultobj;
10322 fail:
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10334 wxString *arg2 = 0 ;
10335 wxString result;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 bool temp2 = false ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "location", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10351 {
10352 arg2 = wxString_in_helper(obj1);
10353 if (arg2 == NULL) SWIG_fail;
10354 temp2 = true;
10355 }
10356 {
10357 PyThreadState* __tstate = wxPyBeginAllowThreads();
10358 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10359 wxPyEndAllowThreads(__tstate);
10360 if (PyErr_Occurred()) SWIG_fail;
10361 }
10362 {
10363 #if wxUSE_UNICODE
10364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10365 #else
10366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10367 #endif
10368 }
10369 {
10370 if (temp2)
10371 delete arg2;
10372 }
10373 return resultobj;
10374 fail:
10375 {
10376 if (temp2)
10377 delete arg2;
10378 }
10379 return NULL;
10380 }
10381
10382
10383 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj = 0;
10385 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10386 wxString *arg2 = 0 ;
10387 wxString result;
10388 void *argp1 = 0 ;
10389 int res1 = 0 ;
10390 bool temp2 = false ;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 char * kwnames[] = {
10394 (char *) "self",(char *) "location", NULL
10395 };
10396
10397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10401 }
10402 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10403 {
10404 arg2 = wxString_in_helper(obj1);
10405 if (arg2 == NULL) SWIG_fail;
10406 temp2 = true;
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 #if wxUSE_UNICODE
10416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10417 #else
10418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10419 #endif
10420 }
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return resultobj;
10426 fail:
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10436 PyObject *obj;
10437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10438 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10439 return SWIG_Py_Void();
10440 }
10441
10442 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10443 return SWIG_Python_InitShadowInstance(args);
10444 }
10445
10446 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10447 PyObject *resultobj = 0;
10448 wxFileSystem *result = 0 ;
10449
10450 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxFileSystem *)new wxFileSystem();
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10459 }
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10467 PyObject *resultobj = 0;
10468 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10469 void *argp1 = 0 ;
10470 int res1 = 0 ;
10471 PyObject *swig_obj[1] ;
10472
10473 if (!args) SWIG_fail;
10474 swig_obj[0] = args;
10475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10476 if (!SWIG_IsOK(res1)) {
10477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10478 }
10479 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 delete arg1;
10483
10484 wxPyEndAllowThreads(__tstate);
10485 if (PyErr_Occurred()) SWIG_fail;
10486 }
10487 resultobj = SWIG_Py_Void();
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj = 0;
10496 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10497 wxString *arg2 = 0 ;
10498 bool arg3 = (bool) false ;
10499 void *argp1 = 0 ;
10500 int res1 = 0 ;
10501 bool temp2 = false ;
10502 bool val3 ;
10503 int ecode3 = 0 ;
10504 PyObject * obj0 = 0 ;
10505 PyObject * obj1 = 0 ;
10506 PyObject * obj2 = 0 ;
10507 char * kwnames[] = {
10508 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10509 };
10510
10511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10515 }
10516 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10517 {
10518 arg2 = wxString_in_helper(obj1);
10519 if (arg2 == NULL) SWIG_fail;
10520 temp2 = true;
10521 }
10522 if (obj2) {
10523 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10524 if (!SWIG_IsOK(ecode3)) {
10525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10526 }
10527 arg3 = static_cast< bool >(val3);
10528 }
10529 {
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10532 wxPyEndAllowThreads(__tstate);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 resultobj = SWIG_Py_Void();
10536 {
10537 if (temp2)
10538 delete arg2;
10539 }
10540 return resultobj;
10541 fail:
10542 {
10543 if (temp2)
10544 delete arg2;
10545 }
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10551 PyObject *resultobj = 0;
10552 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10553 wxString result;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 PyObject *swig_obj[1] ;
10557
10558 if (!args) SWIG_fail;
10559 swig_obj[0] = args;
10560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10563 }
10564 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (arg1)->GetPath();
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 {
10572 #if wxUSE_UNICODE
10573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10574 #else
10575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10576 #endif
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = 0;
10586 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10587 wxString *arg2 = 0 ;
10588 wxFSFile *result = 0 ;
10589 void *argp1 = 0 ;
10590 int res1 = 0 ;
10591 bool temp2 = false ;
10592 PyObject * obj0 = 0 ;
10593 PyObject * obj1 = 0 ;
10594 char * kwnames[] = {
10595 (char *) "self",(char *) "location", NULL
10596 };
10597
10598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10600 if (!SWIG_IsOK(res1)) {
10601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10602 }
10603 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10604 {
10605 arg2 = wxString_in_helper(obj1);
10606 if (arg2 == NULL) SWIG_fail;
10607 temp2 = true;
10608 }
10609 {
10610 PyThreadState* __tstate = wxPyBeginAllowThreads();
10611 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10612 wxPyEndAllowThreads(__tstate);
10613 if (PyErr_Occurred()) SWIG_fail;
10614 }
10615 {
10616 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10617 }
10618 {
10619 if (temp2)
10620 delete arg2;
10621 }
10622 return resultobj;
10623 fail:
10624 {
10625 if (temp2)
10626 delete arg2;
10627 }
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = 0;
10634 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10635 wxString *arg2 = 0 ;
10636 int arg3 = (int) 0 ;
10637 wxString result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 bool temp2 = false ;
10641 int val3 ;
10642 int ecode3 = 0 ;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "spec",(char *) "flags", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10654 }
10655 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10656 {
10657 arg2 = wxString_in_helper(obj1);
10658 if (arg2 == NULL) SWIG_fail;
10659 temp2 = true;
10660 }
10661 if (obj2) {
10662 ecode3 = SWIG_AsVal_int(obj2, &val3);
10663 if (!SWIG_IsOK(ecode3)) {
10664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10665 }
10666 arg3 = static_cast< int >(val3);
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 {
10675 #if wxUSE_UNICODE
10676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10677 #else
10678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10679 #endif
10680 }
10681 {
10682 if (temp2)
10683 delete arg2;
10684 }
10685 return resultobj;
10686 fail:
10687 {
10688 if (temp2)
10689 delete arg2;
10690 }
10691 return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *resultobj = 0;
10697 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10698 wxString result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 PyObject *swig_obj[1] ;
10702
10703 if (!args) SWIG_fail;
10704 swig_obj[0] = args;
10705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10708 }
10709 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (arg1)->FindNext();
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 #if wxUSE_UNICODE
10718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10719 #else
10720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10721 #endif
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = 0;
10731 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10732 int res1 = 0 ;
10733 PyObject * obj0 = 0 ;
10734 char * kwnames[] = {
10735 (char *) "handler", NULL
10736 };
10737
10738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10739 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10740 if (!SWIG_IsOK(res1)) {
10741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10742 }
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 wxFileSystem::AddHandler(arg1);
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_Py_Void();
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10757 PyObject *resultobj = 0;
10758
10759 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 wxFileSystem::CleanUpHandlers();
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_Py_Void();
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj = 0;
10775 wxString *arg1 = 0 ;
10776 wxString result;
10777 bool temp1 = false ;
10778 PyObject * obj0 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "filename", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10784 {
10785 arg1 = wxString_in_helper(obj0);
10786 if (arg1 == NULL) SWIG_fail;
10787 temp1 = true;
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 #if wxUSE_UNICODE
10797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10798 #else
10799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10800 #endif
10801 }
10802 {
10803 if (temp1)
10804 delete arg1;
10805 }
10806 return resultobj;
10807 fail:
10808 {
10809 if (temp1)
10810 delete arg1;
10811 }
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10817 PyObject *resultobj = 0;
10818 wxString *arg1 = 0 ;
10819 wxString result;
10820 bool temp1 = false ;
10821 PyObject * obj0 = 0 ;
10822 char * kwnames[] = {
10823 (char *) "url", NULL
10824 };
10825
10826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10827 {
10828 arg1 = wxString_in_helper(obj0);
10829 if (arg1 == NULL) SWIG_fail;
10830 temp1 = true;
10831 }
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 {
10839 #if wxUSE_UNICODE
10840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10841 #else
10842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10843 #endif
10844 }
10845 {
10846 if (temp1)
10847 delete arg1;
10848 }
10849 return resultobj;
10850 fail:
10851 {
10852 if (temp1)
10853 delete arg1;
10854 }
10855 return NULL;
10856 }
10857
10858
10859 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10860 PyObject *obj;
10861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10862 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10863 return SWIG_Py_Void();
10864 }
10865
10866 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10867 return SWIG_Python_InitShadowInstance(args);
10868 }
10869
10870 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10871 PyObject *resultobj = 0;
10872 wxInternetFSHandler *result = 0 ;
10873
10874 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10891 wxString *arg2 = 0 ;
10892 bool result;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 bool temp2 = false ;
10896 PyObject * obj0 = 0 ;
10897 PyObject * obj1 = 0 ;
10898 char * kwnames[] = {
10899 (char *) "self",(char *) "location", NULL
10900 };
10901
10902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10904 if (!SWIG_IsOK(res1)) {
10905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10906 }
10907 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10908 {
10909 arg2 = wxString_in_helper(obj1);
10910 if (arg2 == NULL) SWIG_fail;
10911 temp2 = true;
10912 }
10913 {
10914 PyThreadState* __tstate = wxPyBeginAllowThreads();
10915 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10916 wxPyEndAllowThreads(__tstate);
10917 if (PyErr_Occurred()) SWIG_fail;
10918 }
10919 {
10920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10921 }
10922 {
10923 if (temp2)
10924 delete arg2;
10925 }
10926 return resultobj;
10927 fail:
10928 {
10929 if (temp2)
10930 delete arg2;
10931 }
10932 return NULL;
10933 }
10934
10935
10936 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj = 0;
10938 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10939 wxFileSystem *arg2 = 0 ;
10940 wxString *arg3 = 0 ;
10941 wxFSFile *result = 0 ;
10942 void *argp1 = 0 ;
10943 int res1 = 0 ;
10944 void *argp2 = 0 ;
10945 int res2 = 0 ;
10946 bool temp3 = false ;
10947 PyObject * obj0 = 0 ;
10948 PyObject * obj1 = 0 ;
10949 PyObject * obj2 = 0 ;
10950 char * kwnames[] = {
10951 (char *) "self",(char *) "fs",(char *) "location", NULL
10952 };
10953
10954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10956 if (!SWIG_IsOK(res1)) {
10957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10958 }
10959 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10961 if (!SWIG_IsOK(res2)) {
10962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10963 }
10964 if (!argp2) {
10965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10966 }
10967 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10968 {
10969 arg3 = wxString_in_helper(obj2);
10970 if (arg3 == NULL) SWIG_fail;
10971 temp3 = true;
10972 }
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 {
10980 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10981 }
10982 {
10983 if (temp3)
10984 delete arg3;
10985 }
10986 return resultobj;
10987 fail:
10988 {
10989 if (temp3)
10990 delete arg3;
10991 }
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10997 PyObject *obj;
10998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10999 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11000 return SWIG_Py_Void();
11001 }
11002
11003 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 return SWIG_Python_InitShadowInstance(args);
11005 }
11006
11007 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *resultobj = 0;
11009 wxZipFSHandler *result = 0 ;
11010
11011 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11012 {
11013 PyThreadState* __tstate = wxPyBeginAllowThreads();
11014 result = (wxZipFSHandler *)new wxZipFSHandler();
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj = 0;
11027 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11028 wxString *arg2 = 0 ;
11029 bool result;
11030 void *argp1 = 0 ;
11031 int res1 = 0 ;
11032 bool temp2 = false ;
11033 PyObject * obj0 = 0 ;
11034 PyObject * obj1 = 0 ;
11035 char * kwnames[] = {
11036 (char *) "self",(char *) "location", NULL
11037 };
11038
11039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11041 if (!SWIG_IsOK(res1)) {
11042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11043 }
11044 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11045 {
11046 arg2 = wxString_in_helper(obj1);
11047 if (arg2 == NULL) SWIG_fail;
11048 temp2 = true;
11049 }
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11058 }
11059 {
11060 if (temp2)
11061 delete arg2;
11062 }
11063 return resultobj;
11064 fail:
11065 {
11066 if (temp2)
11067 delete arg2;
11068 }
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj = 0;
11075 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11076 wxFileSystem *arg2 = 0 ;
11077 wxString *arg3 = 0 ;
11078 wxFSFile *result = 0 ;
11079 void *argp1 = 0 ;
11080 int res1 = 0 ;
11081 void *argp2 = 0 ;
11082 int res2 = 0 ;
11083 bool temp3 = false ;
11084 PyObject * obj0 = 0 ;
11085 PyObject * obj1 = 0 ;
11086 PyObject * obj2 = 0 ;
11087 char * kwnames[] = {
11088 (char *) "self",(char *) "fs",(char *) "location", NULL
11089 };
11090
11091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11093 if (!SWIG_IsOK(res1)) {
11094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11095 }
11096 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11098 if (!SWIG_IsOK(res2)) {
11099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11100 }
11101 if (!argp2) {
11102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11103 }
11104 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11105 {
11106 arg3 = wxString_in_helper(obj2);
11107 if (arg3 == NULL) SWIG_fail;
11108 temp3 = true;
11109 }
11110 {
11111 PyThreadState* __tstate = wxPyBeginAllowThreads();
11112 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 {
11117 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11118 }
11119 {
11120 if (temp3)
11121 delete arg3;
11122 }
11123 return resultobj;
11124 fail:
11125 {
11126 if (temp3)
11127 delete arg3;
11128 }
11129 return NULL;
11130 }
11131
11132
11133 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11134 PyObject *resultobj = 0;
11135 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11136 wxString *arg2 = 0 ;
11137 int arg3 = (int) 0 ;
11138 wxString result;
11139 void *argp1 = 0 ;
11140 int res1 = 0 ;
11141 bool temp2 = false ;
11142 int val3 ;
11143 int ecode3 = 0 ;
11144 PyObject * obj0 = 0 ;
11145 PyObject * obj1 = 0 ;
11146 PyObject * obj2 = 0 ;
11147 char * kwnames[] = {
11148 (char *) "self",(char *) "spec",(char *) "flags", NULL
11149 };
11150
11151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11153 if (!SWIG_IsOK(res1)) {
11154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11155 }
11156 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11157 {
11158 arg2 = wxString_in_helper(obj1);
11159 if (arg2 == NULL) SWIG_fail;
11160 temp2 = true;
11161 }
11162 if (obj2) {
11163 ecode3 = SWIG_AsVal_int(obj2, &val3);
11164 if (!SWIG_IsOK(ecode3)) {
11165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11166 }
11167 arg3 = static_cast< int >(val3);
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 #if wxUSE_UNICODE
11177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11178 #else
11179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11180 #endif
11181 }
11182 {
11183 if (temp2)
11184 delete arg2;
11185 }
11186 return resultobj;
11187 fail:
11188 {
11189 if (temp2)
11190 delete arg2;
11191 }
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11199 wxString result;
11200 void *argp1 = 0 ;
11201 int res1 = 0 ;
11202 PyObject *swig_obj[1] ;
11203
11204 if (!args) SWIG_fail;
11205 swig_obj[0] = args;
11206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11207 if (!SWIG_IsOK(res1)) {
11208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11209 }
11210 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11211 {
11212 PyThreadState* __tstate = wxPyBeginAllowThreads();
11213 result = (arg1)->FindNext();
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 {
11218 #if wxUSE_UNICODE
11219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11220 #else
11221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11222 #endif
11223 }
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11231 PyObject *obj;
11232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11233 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11234 return SWIG_Py_Void();
11235 }
11236
11237 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11238 return SWIG_Python_InitShadowInstance(args);
11239 }
11240
11241 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj = 0;
11243 wxString *arg1 = 0 ;
11244 wxImage *arg2 = 0 ;
11245 long arg3 ;
11246 bool temp1 = false ;
11247 void *argp2 = 0 ;
11248 int res2 = 0 ;
11249 long val3 ;
11250 int ecode3 = 0 ;
11251 PyObject * obj0 = 0 ;
11252 PyObject * obj1 = 0 ;
11253 PyObject * obj2 = 0 ;
11254 char * kwnames[] = {
11255 (char *) "filename",(char *) "image",(char *) "type", NULL
11256 };
11257
11258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11259 {
11260 arg1 = wxString_in_helper(obj0);
11261 if (arg1 == NULL) SWIG_fail;
11262 temp1 = true;
11263 }
11264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11265 if (!SWIG_IsOK(res2)) {
11266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11267 }
11268 if (!argp2) {
11269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11270 }
11271 arg2 = reinterpret_cast< wxImage * >(argp2);
11272 ecode3 = SWIG_AsVal_long(obj2, &val3);
11273 if (!SWIG_IsOK(ecode3)) {
11274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11275 }
11276 arg3 = static_cast< long >(val3);
11277 {
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 resultobj = SWIG_Py_Void();
11284 {
11285 if (temp1)
11286 delete arg1;
11287 }
11288 return resultobj;
11289 fail:
11290 {
11291 if (temp1)
11292 delete arg1;
11293 }
11294 return NULL;
11295 }
11296
11297
11298 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11299 PyObject *resultobj = 0;
11300 wxString *arg1 = 0 ;
11301 wxBitmap *arg2 = 0 ;
11302 long arg3 ;
11303 bool temp1 = false ;
11304 void *argp2 = 0 ;
11305 int res2 = 0 ;
11306 long val3 ;
11307 int ecode3 = 0 ;
11308 PyObject * obj0 = 0 ;
11309 PyObject * obj1 = 0 ;
11310 PyObject * obj2 = 0 ;
11311 char * kwnames[] = {
11312 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11313 };
11314
11315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11316 {
11317 arg1 = wxString_in_helper(obj0);
11318 if (arg1 == NULL) SWIG_fail;
11319 temp1 = true;
11320 }
11321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11322 if (!SWIG_IsOK(res2)) {
11323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11324 }
11325 if (!argp2) {
11326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11327 }
11328 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11329 ecode3 = SWIG_AsVal_long(obj2, &val3);
11330 if (!SWIG_IsOK(ecode3)) {
11331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11332 }
11333 arg3 = static_cast< long >(val3);
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 {
11342 if (temp1)
11343 delete arg1;
11344 }
11345 return resultobj;
11346 fail:
11347 {
11348 if (temp1)
11349 delete arg1;
11350 }
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj = 0;
11357 wxString *arg1 = 0 ;
11358 PyObject *arg2 = (PyObject *) 0 ;
11359 bool temp1 = false ;
11360 PyObject * obj0 = 0 ;
11361 PyObject * obj1 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "filename",(char *) "data", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11367 {
11368 arg1 = wxString_in_helper(obj0);
11369 if (arg1 == NULL) SWIG_fail;
11370 temp1 = true;
11371 }
11372 arg2 = obj1;
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = SWIG_Py_Void();
11380 {
11381 if (temp1)
11382 delete arg1;
11383 }
11384 return resultobj;
11385 fail:
11386 {
11387 if (temp1)
11388 delete arg1;
11389 }
11390 return NULL;
11391 }
11392
11393
11394 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11395 PyObject *resultobj = 0;
11396 wxMemoryFSHandler *result = 0 ;
11397
11398 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11406 return resultobj;
11407 fail:
11408 return NULL;
11409 }
11410
11411
11412 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11413 PyObject *resultobj = 0;
11414 wxString *arg1 = 0 ;
11415 bool temp1 = false ;
11416 PyObject * obj0 = 0 ;
11417 char * kwnames[] = {
11418 (char *) "filename", NULL
11419 };
11420
11421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11430 wxPyEndAllowThreads(__tstate);
11431 if (PyErr_Occurred()) SWIG_fail;
11432 }
11433 resultobj = SWIG_Py_Void();
11434 {
11435 if (temp1)
11436 delete arg1;
11437 }
11438 return resultobj;
11439 fail:
11440 {
11441 if (temp1)
11442 delete arg1;
11443 }
11444 return NULL;
11445 }
11446
11447
11448 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11449 PyObject *resultobj = 0;
11450 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11451 wxString *arg2 = 0 ;
11452 bool result;
11453 void *argp1 = 0 ;
11454 int res1 = 0 ;
11455 bool temp2 = false ;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 char * kwnames[] = {
11459 (char *) "self",(char *) "location", NULL
11460 };
11461
11462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11466 }
11467 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11468 {
11469 arg2 = wxString_in_helper(obj1);
11470 if (arg2 == NULL) SWIG_fail;
11471 temp2 = true;
11472 }
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 {
11480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11481 }
11482 {
11483 if (temp2)
11484 delete arg2;
11485 }
11486 return resultobj;
11487 fail:
11488 {
11489 if (temp2)
11490 delete arg2;
11491 }
11492 return NULL;
11493 }
11494
11495
11496 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11499 wxFileSystem *arg2 = 0 ;
11500 wxString *arg3 = 0 ;
11501 wxFSFile *result = 0 ;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 void *argp2 = 0 ;
11505 int res2 = 0 ;
11506 bool temp3 = false ;
11507 PyObject * obj0 = 0 ;
11508 PyObject * obj1 = 0 ;
11509 PyObject * obj2 = 0 ;
11510 char * kwnames[] = {
11511 (char *) "self",(char *) "fs",(char *) "location", NULL
11512 };
11513
11514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11516 if (!SWIG_IsOK(res1)) {
11517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11518 }
11519 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11520 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11521 if (!SWIG_IsOK(res2)) {
11522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11523 }
11524 if (!argp2) {
11525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11526 }
11527 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11528 {
11529 arg3 = wxString_in_helper(obj2);
11530 if (arg3 == NULL) SWIG_fail;
11531 temp3 = true;
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 {
11540 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11541 }
11542 {
11543 if (temp3)
11544 delete arg3;
11545 }
11546 return resultobj;
11547 fail:
11548 {
11549 if (temp3)
11550 delete arg3;
11551 }
11552 return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11557 PyObject *resultobj = 0;
11558 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11559 wxString *arg2 = 0 ;
11560 int arg3 = (int) 0 ;
11561 wxString result;
11562 void *argp1 = 0 ;
11563 int res1 = 0 ;
11564 bool temp2 = false ;
11565 int val3 ;
11566 int ecode3 = 0 ;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 PyObject * obj2 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "self",(char *) "spec",(char *) "flags", NULL
11572 };
11573
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11576 if (!SWIG_IsOK(res1)) {
11577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11578 }
11579 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11580 {
11581 arg2 = wxString_in_helper(obj1);
11582 if (arg2 == NULL) SWIG_fail;
11583 temp2 = true;
11584 }
11585 if (obj2) {
11586 ecode3 = SWIG_AsVal_int(obj2, &val3);
11587 if (!SWIG_IsOK(ecode3)) {
11588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11589 }
11590 arg3 = static_cast< int >(val3);
11591 }
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 {
11599 #if wxUSE_UNICODE
11600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11601 #else
11602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11603 #endif
11604 }
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return resultobj;
11610 fail:
11611 {
11612 if (temp2)
11613 delete arg2;
11614 }
11615 return NULL;
11616 }
11617
11618
11619 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620 PyObject *resultobj = 0;
11621 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11622 wxString result;
11623 void *argp1 = 0 ;
11624 int res1 = 0 ;
11625 PyObject *swig_obj[1] ;
11626
11627 if (!args) SWIG_fail;
11628 swig_obj[0] = args;
11629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11630 if (!SWIG_IsOK(res1)) {
11631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11632 }
11633 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (arg1)->FindNext();
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 #if wxUSE_UNICODE
11642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11643 #else
11644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11645 #endif
11646 }
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654 PyObject *obj;
11655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11656 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11657 return SWIG_Py_Void();
11658 }
11659
11660 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661 return SWIG_Python_InitShadowInstance(args);
11662 }
11663
11664 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11665 PyObject *resultobj = 0;
11666 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11667 wxString result;
11668 void *argp1 = 0 ;
11669 int res1 = 0 ;
11670 PyObject *swig_obj[1] ;
11671
11672 if (!args) SWIG_fail;
11673 swig_obj[0] = args;
11674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11675 if (!SWIG_IsOK(res1)) {
11676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11677 }
11678 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11679 {
11680 PyThreadState* __tstate = wxPyBeginAllowThreads();
11681 result = (arg1)->GetName();
11682 wxPyEndAllowThreads(__tstate);
11683 if (PyErr_Occurred()) SWIG_fail;
11684 }
11685 {
11686 #if wxUSE_UNICODE
11687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11688 #else
11689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11690 #endif
11691 }
11692 return resultobj;
11693 fail:
11694 return NULL;
11695 }
11696
11697
11698 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699 PyObject *resultobj = 0;
11700 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11701 wxString result;
11702 void *argp1 = 0 ;
11703 int res1 = 0 ;
11704 PyObject *swig_obj[1] ;
11705
11706 if (!args) SWIG_fail;
11707 swig_obj[0] = args;
11708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11711 }
11712 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11713 {
11714 PyThreadState* __tstate = wxPyBeginAllowThreads();
11715 result = (arg1)->GetExtension();
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 #if wxUSE_UNICODE
11721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11722 #else
11723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11724 #endif
11725 }
11726 return resultobj;
11727 fail:
11728 return NULL;
11729 }
11730
11731
11732 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 PyObject *resultobj = 0;
11734 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11735 long result;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 PyObject *swig_obj[1] ;
11739
11740 if (!args) SWIG_fail;
11741 swig_obj[0] = args;
11742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11745 }
11746 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (long)(arg1)->GetType();
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = SWIG_From_long(static_cast< long >(result));
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11761 PyObject *resultobj = 0;
11762 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11763 wxString result;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11773 }
11774 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (arg1)->GetMimeType();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 #if wxUSE_UNICODE
11783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11784 #else
11785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11786 #endif
11787 }
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11795 PyObject *resultobj = 0;
11796 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11797 wxString *arg2 = 0 ;
11798 bool result;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 bool temp2 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "self",(char *) "name", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11812 }
11813 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11814 {
11815 arg2 = wxString_in_helper(obj1);
11816 if (arg2 == NULL) SWIG_fail;
11817 temp2 = true;
11818 }
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 {
11826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11827 }
11828 {
11829 if (temp2)
11830 delete arg2;
11831 }
11832 return resultobj;
11833 fail:
11834 {
11835 if (temp2)
11836 delete arg2;
11837 }
11838 return NULL;
11839 }
11840
11841
11842 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11843 PyObject *resultobj = 0;
11844 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11845 wxString *arg2 = 0 ;
11846 void *argp1 = 0 ;
11847 int res1 = 0 ;
11848 bool temp2 = false ;
11849 PyObject * obj0 = 0 ;
11850 PyObject * obj1 = 0 ;
11851 char * kwnames[] = {
11852 (char *) "self",(char *) "name", NULL
11853 };
11854
11855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11859 }
11860 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11861 {
11862 arg2 = wxString_in_helper(obj1);
11863 if (arg2 == NULL) SWIG_fail;
11864 temp2 = true;
11865 }
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 (arg1)->SetName((wxString const &)*arg2);
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 resultobj = SWIG_Py_Void();
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp2)
11881 delete arg2;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj = 0;
11889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11890 wxString *arg2 = 0 ;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 bool temp2 = false ;
11894 PyObject * obj0 = 0 ;
11895 PyObject * obj1 = 0 ;
11896 char * kwnames[] = {
11897 (char *) "self",(char *) "extension", NULL
11898 };
11899
11900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11902 if (!SWIG_IsOK(res1)) {
11903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11904 }
11905 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 (arg1)->SetExtension((wxString const &)*arg2);
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 resultobj = SWIG_Py_Void();
11918 {
11919 if (temp2)
11920 delete arg2;
11921 }
11922 return resultobj;
11923 fail:
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return NULL;
11929 }
11930
11931
11932 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj = 0;
11934 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11935 long arg2 ;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 long val2 ;
11939 int ecode2 = 0 ;
11940 PyObject * obj0 = 0 ;
11941 PyObject * obj1 = 0 ;
11942 char * kwnames[] = {
11943 (char *) "self",(char *) "type", NULL
11944 };
11945
11946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11948 if (!SWIG_IsOK(res1)) {
11949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11950 }
11951 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11952 ecode2 = SWIG_AsVal_long(obj1, &val2);
11953 if (!SWIG_IsOK(ecode2)) {
11954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11955 }
11956 arg2 = static_cast< long >(val2);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 (arg1)->SetType(arg2);
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 resultobj = SWIG_Py_Void();
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj = 0;
11972 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11973 wxString *arg2 = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 PyObject * obj0 = 0 ;
11978 PyObject * obj1 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "mimetype", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11987 }
11988 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11989 {
11990 arg2 = wxString_in_helper(obj1);
11991 if (arg2 == NULL) SWIG_fail;
11992 temp2 = true;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 (arg1)->SetMimeType((wxString const &)*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 resultobj = SWIG_Py_Void();
12001 {
12002 if (temp2)
12003 delete arg2;
12004 }
12005 return resultobj;
12006 fail:
12007 {
12008 if (temp2)
12009 delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12016 PyObject *obj;
12017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12018 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12019 return SWIG_Py_Void();
12020 }
12021
12022 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12023 PyObject *resultobj = 0;
12024 wxPyImageHandler *result = 0 ;
12025
12026 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (wxPyImageHandler *)new wxPyImageHandler();
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12043 PyObject *arg2 = (PyObject *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "self", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12056 }
12057 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12058 arg2 = obj1;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 (arg1)->_SetSelf(arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *obj;
12074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12076 return SWIG_Py_Void();
12077 }
12078
12079 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 return SWIG_Python_InitShadowInstance(args);
12081 }
12082
12083 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12084 PyObject *resultobj = 0;
12085 wxImageHistogram *result = 0 ;
12086
12087 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 result = (wxImageHistogram *)new wxImageHistogram();
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj = 0;
12103 byte arg1 ;
12104 byte arg2 ;
12105 byte arg3 ;
12106 unsigned long result;
12107 unsigned char val1 ;
12108 int ecode1 = 0 ;
12109 unsigned char val2 ;
12110 int ecode2 = 0 ;
12111 unsigned char val3 ;
12112 int ecode3 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 PyObject * obj2 = 0 ;
12116 char * kwnames[] = {
12117 (char *) "r",(char *) "g",(char *) "b", NULL
12118 };
12119
12120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12121 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12122 if (!SWIG_IsOK(ecode1)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12124 }
12125 arg1 = static_cast< byte >(val1);
12126 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12127 if (!SWIG_IsOK(ecode2)) {
12128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12129 }
12130 arg2 = static_cast< byte >(val2);
12131 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12132 if (!SWIG_IsOK(ecode3)) {
12133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12134 }
12135 arg3 = static_cast< byte >(val3);
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12143 return resultobj;
12144 fail:
12145 return NULL;
12146 }
12147
12148
12149 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12150 PyObject *resultobj = 0;
12151 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12152 byte *arg2 = (byte *) 0 ;
12153 byte *arg3 = (byte *) 0 ;
12154 byte *arg4 = (byte *) 0 ;
12155 byte arg5 = (byte) 1 ;
12156 byte arg6 = (byte) 0 ;
12157 byte arg7 = (byte) 0 ;
12158 bool result;
12159 void *argp1 = 0 ;
12160 int res1 = 0 ;
12161 byte temp2 ;
12162 int res2 = SWIG_TMPOBJ ;
12163 byte temp3 ;
12164 int res3 = SWIG_TMPOBJ ;
12165 byte temp4 ;
12166 int res4 = SWIG_TMPOBJ ;
12167 unsigned char val5 ;
12168 int ecode5 = 0 ;
12169 unsigned char val6 ;
12170 int ecode6 = 0 ;
12171 unsigned char val7 ;
12172 int ecode7 = 0 ;
12173 PyObject * obj0 = 0 ;
12174 PyObject * obj1 = 0 ;
12175 PyObject * obj2 = 0 ;
12176 PyObject * obj3 = 0 ;
12177 char * kwnames[] = {
12178 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12179 };
12180
12181 arg2 = &temp2;
12182 arg3 = &temp3;
12183 arg4 = &temp4;
12184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12186 if (!SWIG_IsOK(res1)) {
12187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12188 }
12189 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12190 if (obj1) {
12191 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12192 if (!SWIG_IsOK(ecode5)) {
12193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12194 }
12195 arg5 = static_cast< byte >(val5);
12196 }
12197 if (obj2) {
12198 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12199 if (!SWIG_IsOK(ecode6)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12201 }
12202 arg6 = static_cast< byte >(val6);
12203 }
12204 if (obj3) {
12205 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12206 if (!SWIG_IsOK(ecode7)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12208 }
12209 arg7 = static_cast< byte >(val7);
12210 }
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12219 }
12220 if (SWIG_IsTmpObj(res2)) {
12221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12222 } else {
12223 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12225 }
12226 if (SWIG_IsTmpObj(res3)) {
12227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12228 } else {
12229 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12231 }
12232 if (SWIG_IsTmpObj(res4)) {
12233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12234 } else {
12235 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12237 }
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj = 0;
12246 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12247 unsigned long arg2 ;
12248 unsigned long result;
12249 void *argp1 = 0 ;
12250 int res1 = 0 ;
12251 unsigned long val2 ;
12252 int ecode2 = 0 ;
12253 PyObject * obj0 = 0 ;
12254 PyObject * obj1 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "self",(char *) "key", NULL
12257 };
12258
12259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12261 if (!SWIG_IsOK(res1)) {
12262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12263 }
12264 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12265 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12266 if (!SWIG_IsOK(ecode2)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12268 }
12269 arg2 = static_cast< unsigned long >(val2);
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj = 0;
12285 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12286 byte arg2 ;
12287 byte arg3 ;
12288 byte arg4 ;
12289 unsigned long result;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 unsigned char val2 ;
12293 int ecode2 = 0 ;
12294 unsigned char val3 ;
12295 int ecode3 = 0 ;
12296 unsigned char val4 ;
12297 int ecode4 = 0 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 PyObject * obj2 = 0 ;
12301 PyObject * obj3 = 0 ;
12302 char * kwnames[] = {
12303 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12304 };
12305
12306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12310 }
12311 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12312 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12313 if (!SWIG_IsOK(ecode2)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12315 }
12316 arg2 = static_cast< byte >(val2);
12317 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12318 if (!SWIG_IsOK(ecode3)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12320 }
12321 arg3 = static_cast< byte >(val3);
12322 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12323 if (!SWIG_IsOK(ecode4)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12325 }
12326 arg4 = static_cast< byte >(val4);
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12330 wxPyEndAllowThreads(__tstate);
12331 if (PyErr_Occurred()) SWIG_fail;
12332 }
12333 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12334 return resultobj;
12335 fail:
12336 return NULL;
12337 }
12338
12339
12340 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj = 0;
12342 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12343 wxColour *arg2 = 0 ;
12344 unsigned long result;
12345 void *argp1 = 0 ;
12346 int res1 = 0 ;
12347 wxColour temp2 ;
12348 PyObject * obj0 = 0 ;
12349 PyObject * obj1 = 0 ;
12350 char * kwnames[] = {
12351 (char *) "self",(char *) "colour", NULL
12352 };
12353
12354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12358 }
12359 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12360 {
12361 arg2 = &temp2;
12362 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378 PyObject *obj;
12379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12380 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12381 return SWIG_Py_Void();
12382 }
12383
12384 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12385 return SWIG_Python_InitShadowInstance(args);
12386 }
12387
12388 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj = 0;
12390 byte arg1 = (byte) 0 ;
12391 byte arg2 = (byte) 0 ;
12392 byte arg3 = (byte) 0 ;
12393 wxImage_RGBValue *result = 0 ;
12394 unsigned char val1 ;
12395 int ecode1 = 0 ;
12396 unsigned char val2 ;
12397 int ecode2 = 0 ;
12398 unsigned char val3 ;
12399 int ecode3 = 0 ;
12400 PyObject * obj0 = 0 ;
12401 PyObject * obj1 = 0 ;
12402 PyObject * obj2 = 0 ;
12403 char * kwnames[] = {
12404 (char *) "r",(char *) "g",(char *) "b", NULL
12405 };
12406
12407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12408 if (obj0) {
12409 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12410 if (!SWIG_IsOK(ecode1)) {
12411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12412 }
12413 arg1 = static_cast< byte >(val1);
12414 }
12415 if (obj1) {
12416 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12417 if (!SWIG_IsOK(ecode2)) {
12418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12419 }
12420 arg2 = static_cast< byte >(val2);
12421 }
12422 if (obj2) {
12423 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12424 if (!SWIG_IsOK(ecode3)) {
12425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12426 }
12427 arg3 = static_cast< byte >(val3);
12428 }
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12445 byte arg2 ;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 unsigned char val2 ;
12449 int ecode2 = 0 ;
12450 PyObject *swig_obj[2] ;
12451
12452 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12456 }
12457 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12458 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12459 if (!SWIG_IsOK(ecode2)) {
12460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12461 }
12462 arg2 = static_cast< byte >(val2);
12463 if (arg1) (arg1)->red = arg2;
12464
12465 resultobj = SWIG_Py_Void();
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12473 PyObject *resultobj = 0;
12474 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12475 byte result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 PyObject *swig_obj[1] ;
12479
12480 if (!args) SWIG_fail;
12481 swig_obj[0] = args;
12482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12487 result = (byte) ((arg1)->red);
12488 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12498 byte arg2 ;
12499 void *argp1 = 0 ;
12500 int res1 = 0 ;
12501 unsigned char val2 ;
12502 int ecode2 = 0 ;
12503 PyObject *swig_obj[2] ;
12504
12505 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12507 if (!SWIG_IsOK(res1)) {
12508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12509 }
12510 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12511 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12512 if (!SWIG_IsOK(ecode2)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12514 }
12515 arg2 = static_cast< byte >(val2);
12516 if (arg1) (arg1)->green = arg2;
12517
12518 resultobj = SWIG_Py_Void();
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12526 PyObject *resultobj = 0;
12527 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12528 byte result;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 PyObject *swig_obj[1] ;
12532
12533 if (!args) SWIG_fail;
12534 swig_obj[0] = args;
12535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12538 }
12539 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12540 result = (byte) ((arg1)->green);
12541 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12549 PyObject *resultobj = 0;
12550 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12551 byte arg2 ;
12552 void *argp1 = 0 ;
12553 int res1 = 0 ;
12554 unsigned char val2 ;
12555 int ecode2 = 0 ;
12556 PyObject *swig_obj[2] ;
12557
12558 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12560 if (!SWIG_IsOK(res1)) {
12561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12562 }
12563 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12564 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12565 if (!SWIG_IsOK(ecode2)) {
12566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12567 }
12568 arg2 = static_cast< byte >(val2);
12569 if (arg1) (arg1)->blue = arg2;
12570
12571 resultobj = SWIG_Py_Void();
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12579 PyObject *resultobj = 0;
12580 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12581 byte result;
12582 void *argp1 = 0 ;
12583 int res1 = 0 ;
12584 PyObject *swig_obj[1] ;
12585
12586 if (!args) SWIG_fail;
12587 swig_obj[0] = args;
12588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12589 if (!SWIG_IsOK(res1)) {
12590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12591 }
12592 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12593 result = (byte) ((arg1)->blue);
12594 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12602 PyObject *obj;
12603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12604 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12605 return SWIG_Py_Void();
12606 }
12607
12608 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 return SWIG_Python_InitShadowInstance(args);
12610 }
12611
12612 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj = 0;
12614 double arg1 = (double) 0.0 ;
12615 double arg2 = (double) 0.0 ;
12616 double arg3 = (double) 0.0 ;
12617 wxImage_HSVValue *result = 0 ;
12618 double val1 ;
12619 int ecode1 = 0 ;
12620 double val2 ;
12621 int ecode2 = 0 ;
12622 double val3 ;
12623 int ecode3 = 0 ;
12624 PyObject * obj0 = 0 ;
12625 PyObject * obj1 = 0 ;
12626 PyObject * obj2 = 0 ;
12627 char * kwnames[] = {
12628 (char *) "h",(char *) "s",(char *) "v", NULL
12629 };
12630
12631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12632 if (obj0) {
12633 ecode1 = SWIG_AsVal_double(obj0, &val1);
12634 if (!SWIG_IsOK(ecode1)) {
12635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12636 }
12637 arg1 = static_cast< double >(val1);
12638 }
12639 if (obj1) {
12640 ecode2 = SWIG_AsVal_double(obj1, &val2);
12641 if (!SWIG_IsOK(ecode2)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12643 }
12644 arg2 = static_cast< double >(val2);
12645 }
12646 if (obj2) {
12647 ecode3 = SWIG_AsVal_double(obj2, &val3);
12648 if (!SWIG_IsOK(ecode3)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12650 }
12651 arg3 = static_cast< double >(val3);
12652 }
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12667 PyObject *resultobj = 0;
12668 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12669 double arg2 ;
12670 void *argp1 = 0 ;
12671 int res1 = 0 ;
12672 double val2 ;
12673 int ecode2 = 0 ;
12674 PyObject *swig_obj[2] ;
12675
12676 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12678 if (!SWIG_IsOK(res1)) {
12679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12680 }
12681 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12682 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12683 if (!SWIG_IsOK(ecode2)) {
12684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12685 }
12686 arg2 = static_cast< double >(val2);
12687 if (arg1) (arg1)->hue = arg2;
12688
12689 resultobj = SWIG_Py_Void();
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12697 PyObject *resultobj = 0;
12698 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12699 double result;
12700 void *argp1 = 0 ;
12701 int res1 = 0 ;
12702 PyObject *swig_obj[1] ;
12703
12704 if (!args) SWIG_fail;
12705 swig_obj[0] = args;
12706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12707 if (!SWIG_IsOK(res1)) {
12708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12709 }
12710 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12711 result = (double) ((arg1)->hue);
12712 resultobj = SWIG_From_double(static_cast< double >(result));
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 PyObject *resultobj = 0;
12721 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12722 double arg2 ;
12723 void *argp1 = 0 ;
12724 int res1 = 0 ;
12725 double val2 ;
12726 int ecode2 = 0 ;
12727 PyObject *swig_obj[2] ;
12728
12729 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12731 if (!SWIG_IsOK(res1)) {
12732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12733 }
12734 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12735 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12736 if (!SWIG_IsOK(ecode2)) {
12737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12738 }
12739 arg2 = static_cast< double >(val2);
12740 if (arg1) (arg1)->saturation = arg2;
12741
12742 resultobj = SWIG_Py_Void();
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *resultobj = 0;
12751 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12752 double result;
12753 void *argp1 = 0 ;
12754 int res1 = 0 ;
12755 PyObject *swig_obj[1] ;
12756
12757 if (!args) SWIG_fail;
12758 swig_obj[0] = args;
12759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12762 }
12763 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12764 result = (double) ((arg1)->saturation);
12765 resultobj = SWIG_From_double(static_cast< double >(result));
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12775 double arg2 ;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 double val2 ;
12779 int ecode2 = 0 ;
12780 PyObject *swig_obj[2] ;
12781
12782 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12784 if (!SWIG_IsOK(res1)) {
12785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12786 }
12787 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12788 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12789 if (!SWIG_IsOK(ecode2)) {
12790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12791 }
12792 arg2 = static_cast< double >(val2);
12793 if (arg1) (arg1)->value = arg2;
12794
12795 resultobj = SWIG_Py_Void();
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12805 double result;
12806 void *argp1 = 0 ;
12807 int res1 = 0 ;
12808 PyObject *swig_obj[1] ;
12809
12810 if (!args) SWIG_fail;
12811 swig_obj[0] = args;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12817 result = (double) ((arg1)->value);
12818 resultobj = SWIG_From_double(static_cast< double >(result));
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *obj;
12827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12828 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12829 return SWIG_Py_Void();
12830 }
12831
12832 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 return SWIG_Python_InitShadowInstance(args);
12834 }
12835
12836 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12837 PyObject *resultobj = 0;
12838 wxString *arg1 = 0 ;
12839 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12840 int arg3 = (int) -1 ;
12841 wxImage *result = 0 ;
12842 bool temp1 = false ;
12843 long val2 ;
12844 int ecode2 = 0 ;
12845 int val3 ;
12846 int ecode3 = 0 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 char * kwnames[] = {
12851 (char *) "name",(char *) "type",(char *) "index", NULL
12852 };
12853
12854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12855 {
12856 arg1 = wxString_in_helper(obj0);
12857 if (arg1 == NULL) SWIG_fail;
12858 temp1 = true;
12859 }
12860 if (obj1) {
12861 ecode2 = SWIG_AsVal_long(obj1, &val2);
12862 if (!SWIG_IsOK(ecode2)) {
12863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12864 }
12865 arg2 = static_cast< long >(val2);
12866 }
12867 if (obj2) {
12868 ecode3 = SWIG_AsVal_int(obj2, &val3);
12869 if (!SWIG_IsOK(ecode3)) {
12870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12871 }
12872 arg3 = static_cast< int >(val3);
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12881 {
12882 if (temp1)
12883 delete arg1;
12884 }
12885 return resultobj;
12886 fail:
12887 {
12888 if (temp1)
12889 delete arg1;
12890 }
12891 return NULL;
12892 }
12893
12894
12895 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12896 PyObject *resultobj = 0;
12897 wxImage *arg1 = (wxImage *) 0 ;
12898 void *argp1 = 0 ;
12899 int res1 = 0 ;
12900 PyObject *swig_obj[1] ;
12901
12902 if (!args) SWIG_fail;
12903 swig_obj[0] = args;
12904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12905 if (!SWIG_IsOK(res1)) {
12906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12907 }
12908 arg1 = reinterpret_cast< wxImage * >(argp1);
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 delete arg1;
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 resultobj = SWIG_Py_Void();
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj = 0;
12925 wxString *arg1 = 0 ;
12926 wxString *arg2 = 0 ;
12927 int arg3 = (int) -1 ;
12928 wxImage *result = 0 ;
12929 bool temp1 = false ;
12930 bool temp2 = false ;
12931 int val3 ;
12932 int ecode3 = 0 ;
12933 PyObject * obj0 = 0 ;
12934 PyObject * obj1 = 0 ;
12935 PyObject * obj2 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12941 {
12942 arg1 = wxString_in_helper(obj0);
12943 if (arg1 == NULL) SWIG_fail;
12944 temp1 = true;
12945 }
12946 {
12947 arg2 = wxString_in_helper(obj1);
12948 if (arg2 == NULL) SWIG_fail;
12949 temp2 = true;
12950 }
12951 if (obj2) {
12952 ecode3 = SWIG_AsVal_int(obj2, &val3);
12953 if (!SWIG_IsOK(ecode3)) {
12954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12955 }
12956 arg3 = static_cast< int >(val3);
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12965 {
12966 if (temp1)
12967 delete arg1;
12968 }
12969 {
12970 if (temp2)
12971 delete arg2;
12972 }
12973 return resultobj;
12974 fail:
12975 {
12976 if (temp1)
12977 delete arg1;
12978 }
12979 {
12980 if (temp2)
12981 delete arg2;
12982 }
12983 return NULL;
12984 }
12985
12986
12987 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12988 PyObject *resultobj = 0;
12989 wxInputStream *arg1 = 0 ;
12990 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12991 int arg3 = (int) -1 ;
12992 wxImage *result = 0 ;
12993 wxPyInputStream *temp1 ;
12994 bool created1 ;
12995 long val2 ;
12996 int ecode2 = 0 ;
12997 int val3 ;
12998 int ecode3 = 0 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 char * kwnames[] = {
13003 (char *) "stream",(char *) "type",(char *) "index", NULL
13004 };
13005
13006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13007 {
13008 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13009 arg1 = temp1->m_wxis;
13010 created1 = false;
13011 } else {
13012 PyErr_Clear(); // clear the failure of the wxPyConvert above
13013 arg1 = wxPyCBInputStream_create(obj0, false);
13014 if (arg1 == NULL) {
13015 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13016 SWIG_fail;
13017 }
13018 created1 = true;
13019 }
13020 }
13021 if (obj1) {
13022 ecode2 = SWIG_AsVal_long(obj1, &val2);
13023 if (!SWIG_IsOK(ecode2)) {
13024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13025 }
13026 arg2 = static_cast< long >(val2);
13027 }
13028 if (obj2) {
13029 ecode3 = SWIG_AsVal_int(obj2, &val3);
13030 if (!SWIG_IsOK(ecode3)) {
13031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13032 }
13033 arg3 = static_cast< int >(val3);
13034 }
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13038 wxPyEndAllowThreads(__tstate);
13039 if (PyErr_Occurred()) SWIG_fail;
13040 }
13041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13042 {
13043 if (created1) delete arg1;
13044 }
13045 return resultobj;
13046 fail:
13047 {
13048 if (created1) delete arg1;
13049 }
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxInputStream *arg1 = 0 ;
13057 wxString *arg2 = 0 ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 wxPyInputStream *temp1 ;
13061 bool created1 ;
13062 bool temp2 = false ;
13063 int val3 ;
13064 int ecode3 = 0 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 PyObject * obj2 = 0 ;
13068 char * kwnames[] = {
13069 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13070 };
13071
13072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13073 {
13074 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13075 arg1 = temp1->m_wxis;
13076 created1 = false;
13077 } else {
13078 PyErr_Clear(); // clear the failure of the wxPyConvert above
13079 arg1 = wxPyCBInputStream_create(obj0, false);
13080 if (arg1 == NULL) {
13081 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13082 SWIG_fail;
13083 }
13084 created1 = true;
13085 }
13086 }
13087 {
13088 arg2 = wxString_in_helper(obj1);
13089 if (arg2 == NULL) SWIG_fail;
13090 temp2 = true;
13091 }
13092 if (obj2) {
13093 ecode3 = SWIG_AsVal_int(obj2, &val3);
13094 if (!SWIG_IsOK(ecode3)) {
13095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13096 }
13097 arg3 = static_cast< int >(val3);
13098 }
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13106 {
13107 if (created1) delete arg1;
13108 }
13109 {
13110 if (temp2)
13111 delete arg2;
13112 }
13113 return resultobj;
13114 fail:
13115 {
13116 if (created1) delete arg1;
13117 }
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj = 0;
13128 int arg1 = (int) 0 ;
13129 int arg2 = (int) 0 ;
13130 bool arg3 = (bool) true ;
13131 wxImage *result = 0 ;
13132 int val1 ;
13133 int ecode1 = 0 ;
13134 int val2 ;
13135 int ecode2 = 0 ;
13136 bool val3 ;
13137 int ecode3 = 0 ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 PyObject * obj2 = 0 ;
13141 char * kwnames[] = {
13142 (char *) "width",(char *) "height",(char *) "clear", NULL
13143 };
13144
13145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13146 if (obj0) {
13147 ecode1 = SWIG_AsVal_int(obj0, &val1);
13148 if (!SWIG_IsOK(ecode1)) {
13149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13150 }
13151 arg1 = static_cast< int >(val1);
13152 }
13153 if (obj1) {
13154 ecode2 = SWIG_AsVal_int(obj1, &val2);
13155 if (!SWIG_IsOK(ecode2)) {
13156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13157 }
13158 arg2 = static_cast< int >(val2);
13159 }
13160 if (obj2) {
13161 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13162 if (!SWIG_IsOK(ecode3)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13164 }
13165 arg3 = static_cast< bool >(val3);
13166 }
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13174 return resultobj;
13175 fail:
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxBitmap *arg1 = 0 ;
13183 wxImage *result = 0 ;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 PyObject * obj0 = 0 ;
13187 char * kwnames[] = {
13188 (char *) "bitmap", NULL
13189 };
13190
13191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13192 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13193 if (!SWIG_IsOK(res1)) {
13194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13195 }
13196 if (!argp1) {
13197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13198 }
13199 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13200 {
13201 if (!wxPyCheckForApp()) SWIG_fail;
13202 PyThreadState* __tstate = wxPyBeginAllowThreads();
13203 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = 0;
13216 int arg1 ;
13217 int arg2 ;
13218 buffer arg3 ;
13219 int arg4 ;
13220 wxImage *result = 0 ;
13221 int val1 ;
13222 int ecode1 = 0 ;
13223 int val2 ;
13224 int ecode2 = 0 ;
13225 PyObject * obj0 = 0 ;
13226 PyObject * obj1 = 0 ;
13227 PyObject * obj2 = 0 ;
13228 char * kwnames[] = {
13229 (char *) "width",(char *) "height",(char *) "data", NULL
13230 };
13231
13232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13233 ecode1 = SWIG_AsVal_int(obj0, &val1);
13234 if (!SWIG_IsOK(ecode1)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13236 }
13237 arg1 = static_cast< int >(val1);
13238 ecode2 = SWIG_AsVal_int(obj1, &val2);
13239 if (!SWIG_IsOK(ecode2)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13241 }
13242 arg2 = static_cast< int >(val2);
13243 {
13244 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj = 0;
13261 int arg1 ;
13262 int arg2 ;
13263 buffer arg3 ;
13264 int arg4 ;
13265 buffer arg5 ;
13266 int arg6 ;
13267 wxImage *result = 0 ;
13268 int val1 ;
13269 int ecode1 = 0 ;
13270 int val2 ;
13271 int ecode2 = 0 ;
13272 PyObject * obj0 = 0 ;
13273 PyObject * obj1 = 0 ;
13274 PyObject * obj2 = 0 ;
13275 PyObject * obj3 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13281 ecode1 = SWIG_AsVal_int(obj0, &val1);
13282 if (!SWIG_IsOK(ecode1)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13284 }
13285 arg1 = static_cast< int >(val1);
13286 ecode2 = SWIG_AsVal_int(obj1, &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13289 }
13290 arg2 = static_cast< int >(val2);
13291 {
13292 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13293 }
13294 {
13295 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxImage *arg1 = (wxImage *) 0 ;
13313 int arg2 ;
13314 int arg3 ;
13315 bool arg4 = (bool) true ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 int val2 ;
13319 int ecode2 = 0 ;
13320 int val3 ;
13321 int ecode3 = 0 ;
13322 bool val4 ;
13323 int ecode4 = 0 ;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 PyObject * obj2 = 0 ;
13327 PyObject * obj3 = 0 ;
13328 char * kwnames[] = {
13329 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13330 };
13331
13332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13334 if (!SWIG_IsOK(res1)) {
13335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13336 }
13337 arg1 = reinterpret_cast< wxImage * >(argp1);
13338 ecode2 = SWIG_AsVal_int(obj1, &val2);
13339 if (!SWIG_IsOK(ecode2)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13341 }
13342 arg2 = static_cast< int >(val2);
13343 ecode3 = SWIG_AsVal_int(obj2, &val3);
13344 if (!SWIG_IsOK(ecode3)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13346 }
13347 arg3 = static_cast< int >(val3);
13348 if (obj3) {
13349 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13350 if (!SWIG_IsOK(ecode4)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13352 }
13353 arg4 = static_cast< bool >(val4);
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->Create(arg2,arg3,arg4);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_Py_Void();
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13369 PyObject *resultobj = 0;
13370 wxImage *arg1 = (wxImage *) 0 ;
13371 void *argp1 = 0 ;
13372 int res1 = 0 ;
13373 PyObject *swig_obj[1] ;
13374
13375 if (!args) SWIG_fail;
13376 swig_obj[0] = args;
13377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13378 if (!SWIG_IsOK(res1)) {
13379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13380 }
13381 arg1 = reinterpret_cast< wxImage * >(argp1);
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 (arg1)->Destroy();
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 resultobj = SWIG_Py_Void();
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13396 PyObject *resultobj = 0;
13397 wxImage *arg1 = (wxImage *) 0 ;
13398 int arg2 ;
13399 int arg3 ;
13400 SwigValueWrapper<wxImage > result;
13401 void *argp1 = 0 ;
13402 int res1 = 0 ;
13403 int val2 ;
13404 int ecode2 = 0 ;
13405 int val3 ;
13406 int ecode3 = 0 ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 PyObject * obj2 = 0 ;
13410 char * kwnames[] = {
13411 (char *) "self",(char *) "width",(char *) "height", NULL
13412 };
13413
13414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13418 }
13419 arg1 = reinterpret_cast< wxImage * >(argp1);
13420 ecode2 = SWIG_AsVal_int(obj1, &val2);
13421 if (!SWIG_IsOK(ecode2)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13423 }
13424 arg2 = static_cast< int >(val2);
13425 ecode3 = SWIG_AsVal_int(obj2, &val3);
13426 if (!SWIG_IsOK(ecode3)) {
13427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13428 }
13429 arg3 = static_cast< int >(val3);
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 result = (arg1)->Scale(arg2,arg3);
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj = 0;
13445 wxImage *arg1 = (wxImage *) 0 ;
13446 int arg2 ;
13447 int arg3 ;
13448 SwigValueWrapper<wxImage > result;
13449 void *argp1 = 0 ;
13450 int res1 = 0 ;
13451 int val2 ;
13452 int ecode2 = 0 ;
13453 int val3 ;
13454 int ecode3 = 0 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 PyObject * obj2 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13466 }
13467 arg1 = reinterpret_cast< wxImage * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 ecode3 = SWIG_AsVal_int(obj2, &val3);
13474 if (!SWIG_IsOK(ecode3)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13476 }
13477 arg3 = static_cast< int >(val3);
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = 0;
13493 wxImage *arg1 = (wxImage *) 0 ;
13494 int arg2 ;
13495 int arg3 ;
13496 wxImage *result = 0 ;
13497 void *argp1 = 0 ;
13498 int res1 = 0 ;
13499 int val2 ;
13500 int ecode2 = 0 ;
13501 int val3 ;
13502 int ecode3 = 0 ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 PyObject * obj2 = 0 ;
13506 char * kwnames[] = {
13507 (char *) "self",(char *) "width",(char *) "height", NULL
13508 };
13509
13510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13512 if (!SWIG_IsOK(res1)) {
13513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13514 }
13515 arg1 = reinterpret_cast< wxImage * >(argp1);
13516 ecode2 = SWIG_AsVal_int(obj1, &val2);
13517 if (!SWIG_IsOK(ecode2)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13519 }
13520 arg2 = static_cast< int >(val2);
13521 ecode3 = SWIG_AsVal_int(obj2, &val3);
13522 if (!SWIG_IsOK(ecode3)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13524 }
13525 arg3 = static_cast< int >(val3);
13526 {
13527 PyThreadState* __tstate = wxPyBeginAllowThreads();
13528 {
13529 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13530 result = (wxImage *) &_result_ref;
13531 }
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj = 0;
13544 wxImage *arg1 = (wxImage *) 0 ;
13545 wxSize *arg2 = 0 ;
13546 wxPoint *arg3 = 0 ;
13547 int arg4 = (int) -1 ;
13548 int arg5 = (int) -1 ;
13549 int arg6 = (int) -1 ;
13550 wxImage *result = 0 ;
13551 void *argp1 = 0 ;
13552 int res1 = 0 ;
13553 wxSize temp2 ;
13554 wxPoint temp3 ;
13555 int val4 ;
13556 int ecode4 = 0 ;
13557 int val5 ;
13558 int ecode5 = 0 ;
13559 int val6 ;
13560 int ecode6 = 0 ;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 PyObject * obj2 = 0 ;
13564 PyObject * obj3 = 0 ;
13565 PyObject * obj4 = 0 ;
13566 PyObject * obj5 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13575 }
13576 arg1 = reinterpret_cast< wxImage * >(argp1);
13577 {
13578 arg2 = &temp2;
13579 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13580 }
13581 {
13582 arg3 = &temp3;
13583 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13584 }
13585 if (obj3) {
13586 ecode4 = SWIG_AsVal_int(obj3, &val4);
13587 if (!SWIG_IsOK(ecode4)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13589 }
13590 arg4 = static_cast< int >(val4);
13591 }
13592 if (obj4) {
13593 ecode5 = SWIG_AsVal_int(obj4, &val5);
13594 if (!SWIG_IsOK(ecode5)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13596 }
13597 arg5 = static_cast< int >(val5);
13598 }
13599 if (obj5) {
13600 ecode6 = SWIG_AsVal_int(obj5, &val6);
13601 if (!SWIG_IsOK(ecode6)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13603 }
13604 arg6 = static_cast< int >(val6);
13605 }
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 {
13609 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13610 result = (wxImage *) &_result_ref;
13611 }
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 int arg2 ;
13626 int arg3 ;
13627 byte arg4 ;
13628 byte arg5 ;
13629 byte arg6 ;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 int val3 ;
13635 int ecode3 = 0 ;
13636 unsigned char val4 ;
13637 int ecode4 = 0 ;
13638 unsigned char val5 ;
13639 int ecode5 = 0 ;
13640 unsigned char val6 ;
13641 int ecode6 = 0 ;
13642 PyObject * obj0 = 0 ;
13643 PyObject * obj1 = 0 ;
13644 PyObject * obj2 = 0 ;
13645 PyObject * obj3 = 0 ;
13646 PyObject * obj4 = 0 ;
13647 PyObject * obj5 = 0 ;
13648 char * kwnames[] = {
13649 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13650 };
13651
13652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13654 if (!SWIG_IsOK(res1)) {
13655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13656 }
13657 arg1 = reinterpret_cast< wxImage * >(argp1);
13658 ecode2 = SWIG_AsVal_int(obj1, &val2);
13659 if (!SWIG_IsOK(ecode2)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13661 }
13662 arg2 = static_cast< int >(val2);
13663 ecode3 = SWIG_AsVal_int(obj2, &val3);
13664 if (!SWIG_IsOK(ecode3)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13666 }
13667 arg3 = static_cast< int >(val3);
13668 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13669 if (!SWIG_IsOK(ecode4)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13671 }
13672 arg4 = static_cast< byte >(val4);
13673 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13674 if (!SWIG_IsOK(ecode5)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13676 }
13677 arg5 = static_cast< byte >(val5);
13678 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13679 if (!SWIG_IsOK(ecode6)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13681 }
13682 arg6 = static_cast< byte >(val6);
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_Py_Void();
13690 return resultobj;
13691 fail:
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 wxImage *arg1 = (wxImage *) 0 ;
13699 wxRect *arg2 = 0 ;
13700 byte arg3 ;
13701 byte arg4 ;
13702 byte arg5 ;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 wxRect temp2 ;
13706 unsigned char val3 ;
13707 int ecode3 = 0 ;
13708 unsigned char val4 ;
13709 int ecode4 = 0 ;
13710 unsigned char val5 ;
13711 int ecode5 = 0 ;
13712 PyObject * obj0 = 0 ;
13713 PyObject * obj1 = 0 ;
13714 PyObject * obj2 = 0 ;
13715 PyObject * obj3 = 0 ;
13716 PyObject * obj4 = 0 ;
13717 char * kwnames[] = {
13718 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13719 };
13720
13721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13723 if (!SWIG_IsOK(res1)) {
13724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13725 }
13726 arg1 = reinterpret_cast< wxImage * >(argp1);
13727 {
13728 arg2 = &temp2;
13729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13730 }
13731 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13732 if (!SWIG_IsOK(ecode3)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13734 }
13735 arg3 = static_cast< byte >(val3);
13736 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13737 if (!SWIG_IsOK(ecode4)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13739 }
13740 arg4 = static_cast< byte >(val4);
13741 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13742 if (!SWIG_IsOK(ecode5)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13744 }
13745 arg5 = static_cast< byte >(val5);
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
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_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 wxImage *arg1 = (wxImage *) 0 ;
13762 int arg2 ;
13763 int arg3 ;
13764 byte result;
13765 void *argp1 = 0 ;
13766 int res1 = 0 ;
13767 int val2 ;
13768 int ecode2 = 0 ;
13769 int val3 ;
13770 int ecode3 = 0 ;
13771 PyObject * obj0 = 0 ;
13772 PyObject * obj1 = 0 ;
13773 PyObject * obj2 = 0 ;
13774 char * kwnames[] = {
13775 (char *) "self",(char *) "x",(char *) "y", NULL
13776 };
13777
13778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13780 if (!SWIG_IsOK(res1)) {
13781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13782 }
13783 arg1 = reinterpret_cast< wxImage * >(argp1);
13784 ecode2 = SWIG_AsVal_int(obj1, &val2);
13785 if (!SWIG_IsOK(ecode2)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13787 }
13788 arg2 = static_cast< int >(val2);
13789 ecode3 = SWIG_AsVal_int(obj2, &val3);
13790 if (!SWIG_IsOK(ecode3)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13792 }
13793 arg3 = static_cast< int >(val3);
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 result = (byte)(arg1)->GetRed(arg2,arg3);
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13801 return resultobj;
13802 fail:
13803 return NULL;
13804 }
13805
13806
13807 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj = 0;
13809 wxImage *arg1 = (wxImage *) 0 ;
13810 int arg2 ;
13811 int arg3 ;
13812 byte result;
13813 void *argp1 = 0 ;
13814 int res1 = 0 ;
13815 int val2 ;
13816 int ecode2 = 0 ;
13817 int val3 ;
13818 int ecode3 = 0 ;
13819 PyObject * obj0 = 0 ;
13820 PyObject * obj1 = 0 ;
13821 PyObject * obj2 = 0 ;
13822 char * kwnames[] = {
13823 (char *) "self",(char *) "x",(char *) "y", NULL
13824 };
13825
13826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13828 if (!SWIG_IsOK(res1)) {
13829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13830 }
13831 arg1 = reinterpret_cast< wxImage * >(argp1);
13832 ecode2 = SWIG_AsVal_int(obj1, &val2);
13833 if (!SWIG_IsOK(ecode2)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13835 }
13836 arg2 = static_cast< int >(val2);
13837 ecode3 = SWIG_AsVal_int(obj2, &val3);
13838 if (!SWIG_IsOK(ecode3)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13840 }
13841 arg3 = static_cast< int >(val3);
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (byte)(arg1)->GetGreen(arg2,arg3);
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxImage *arg1 = (wxImage *) 0 ;
13858 int arg2 ;
13859 int arg3 ;
13860 byte result;
13861 void *argp1 = 0 ;
13862 int res1 = 0 ;
13863 int val2 ;
13864 int ecode2 = 0 ;
13865 int val3 ;
13866 int ecode3 = 0 ;
13867 PyObject * obj0 = 0 ;
13868 PyObject * obj1 = 0 ;
13869 PyObject * obj2 = 0 ;
13870 char * kwnames[] = {
13871 (char *) "self",(char *) "x",(char *) "y", NULL
13872 };
13873
13874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13876 if (!SWIG_IsOK(res1)) {
13877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13878 }
13879 arg1 = reinterpret_cast< wxImage * >(argp1);
13880 ecode2 = SWIG_AsVal_int(obj1, &val2);
13881 if (!SWIG_IsOK(ecode2)) {
13882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13883 }
13884 arg2 = static_cast< int >(val2);
13885 ecode3 = SWIG_AsVal_int(obj2, &val3);
13886 if (!SWIG_IsOK(ecode3)) {
13887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13888 }
13889 arg3 = static_cast< int >(val3);
13890 {
13891 PyThreadState* __tstate = wxPyBeginAllowThreads();
13892 result = (byte)(arg1)->GetBlue(arg2,arg3);
13893 wxPyEndAllowThreads(__tstate);
13894 if (PyErr_Occurred()) SWIG_fail;
13895 }
13896 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13897 return resultobj;
13898 fail:
13899 return NULL;
13900 }
13901
13902
13903 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13904 PyObject *resultobj = 0;
13905 wxImage *arg1 = (wxImage *) 0 ;
13906 int arg2 ;
13907 int arg3 ;
13908 byte arg4 ;
13909 void *argp1 = 0 ;
13910 int res1 = 0 ;
13911 int val2 ;
13912 int ecode2 = 0 ;
13913 int val3 ;
13914 int ecode3 = 0 ;
13915 unsigned char val4 ;
13916 int ecode4 = 0 ;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 PyObject * obj2 = 0 ;
13920 PyObject * obj3 = 0 ;
13921 char * kwnames[] = {
13922 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13923 };
13924
13925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13927 if (!SWIG_IsOK(res1)) {
13928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13929 }
13930 arg1 = reinterpret_cast< wxImage * >(argp1);
13931 ecode2 = SWIG_AsVal_int(obj1, &val2);
13932 if (!SWIG_IsOK(ecode2)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13934 }
13935 arg2 = static_cast< int >(val2);
13936 ecode3 = SWIG_AsVal_int(obj2, &val3);
13937 if (!SWIG_IsOK(ecode3)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13939 }
13940 arg3 = static_cast< int >(val3);
13941 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13942 if (!SWIG_IsOK(ecode4)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13944 }
13945 arg4 = static_cast< byte >(val4);
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 (arg1)->SetAlpha(arg2,arg3,arg4);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj = 0;
13961 wxImage *arg1 = (wxImage *) 0 ;
13962 int arg2 ;
13963 int arg3 ;
13964 byte result;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 int val2 ;
13968 int ecode2 = 0 ;
13969 int val3 ;
13970 int ecode3 = 0 ;
13971 PyObject * obj0 = 0 ;
13972 PyObject * obj1 = 0 ;
13973 PyObject * obj2 = 0 ;
13974 char * kwnames[] = {
13975 (char *) "self",(char *) "x",(char *) "y", NULL
13976 };
13977
13978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13980 if (!SWIG_IsOK(res1)) {
13981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13982 }
13983 arg1 = reinterpret_cast< wxImage * >(argp1);
13984 ecode2 = SWIG_AsVal_int(obj1, &val2);
13985 if (!SWIG_IsOK(ecode2)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13987 }
13988 arg2 = static_cast< int >(val2);
13989 ecode3 = SWIG_AsVal_int(obj2, &val3);
13990 if (!SWIG_IsOK(ecode3)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13992 }
13993 arg3 = static_cast< int >(val3);
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14001 return resultobj;
14002 fail:
14003 return NULL;
14004 }
14005
14006
14007 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14008 PyObject *resultobj = 0;
14009 wxImage *arg1 = (wxImage *) 0 ;
14010 bool result;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 PyObject *swig_obj[1] ;
14014
14015 if (!args) SWIG_fail;
14016 swig_obj[0] = args;
14017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14020 }
14021 arg1 = reinterpret_cast< wxImage * >(argp1);
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 result = (bool)(arg1)->HasAlpha();
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 {
14029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14038 PyObject *resultobj = 0;
14039 wxImage *arg1 = (wxImage *) 0 ;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 PyObject *swig_obj[1] ;
14043
14044 if (!args) SWIG_fail;
14045 swig_obj[0] = args;
14046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14049 }
14050 arg1 = reinterpret_cast< wxImage * >(argp1);
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 (arg1)->InitAlpha();
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 resultobj = SWIG_Py_Void();
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = 0;
14066 wxImage *arg1 = (wxImage *) 0 ;
14067 int arg2 ;
14068 int arg3 ;
14069 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14070 bool result;
14071 void *argp1 = 0 ;
14072 int res1 = 0 ;
14073 int val2 ;
14074 int ecode2 = 0 ;
14075 int val3 ;
14076 int ecode3 = 0 ;
14077 unsigned char val4 ;
14078 int ecode4 = 0 ;
14079 PyObject * obj0 = 0 ;
14080 PyObject * obj1 = 0 ;
14081 PyObject * obj2 = 0 ;
14082 PyObject * obj3 = 0 ;
14083 char * kwnames[] = {
14084 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14085 };
14086
14087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14089 if (!SWIG_IsOK(res1)) {
14090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14091 }
14092 arg1 = reinterpret_cast< wxImage * >(argp1);
14093 ecode2 = SWIG_AsVal_int(obj1, &val2);
14094 if (!SWIG_IsOK(ecode2)) {
14095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14096 }
14097 arg2 = static_cast< int >(val2);
14098 ecode3 = SWIG_AsVal_int(obj2, &val3);
14099 if (!SWIG_IsOK(ecode3)) {
14100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14101 }
14102 arg3 = static_cast< int >(val3);
14103 if (obj3) {
14104 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14105 if (!SWIG_IsOK(ecode4)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14107 }
14108 arg4 = static_cast< byte >(val4);
14109 }
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj = 0;
14127 wxImage *arg1 = (wxImage *) 0 ;
14128 byte *arg2 = (byte *) 0 ;
14129 byte *arg3 = (byte *) 0 ;
14130 byte *arg4 = (byte *) 0 ;
14131 byte arg5 = (byte) 0 ;
14132 byte arg6 = (byte) 0 ;
14133 byte arg7 = (byte) 0 ;
14134 bool result;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 byte temp2 ;
14138 int res2 = SWIG_TMPOBJ ;
14139 byte temp3 ;
14140 int res3 = SWIG_TMPOBJ ;
14141 byte temp4 ;
14142 int res4 = SWIG_TMPOBJ ;
14143 unsigned char val5 ;
14144 int ecode5 = 0 ;
14145 unsigned char val6 ;
14146 int ecode6 = 0 ;
14147 unsigned char val7 ;
14148 int ecode7 = 0 ;
14149 PyObject * obj0 = 0 ;
14150 PyObject * obj1 = 0 ;
14151 PyObject * obj2 = 0 ;
14152 PyObject * obj3 = 0 ;
14153 char * kwnames[] = {
14154 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14155 };
14156
14157 arg2 = &temp2;
14158 arg3 = &temp3;
14159 arg4 = &temp4;
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 if (obj1) {
14167 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14168 if (!SWIG_IsOK(ecode5)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14170 }
14171 arg5 = static_cast< byte >(val5);
14172 }
14173 if (obj2) {
14174 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14175 if (!SWIG_IsOK(ecode6)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14177 }
14178 arg6 = static_cast< byte >(val6);
14179 }
14180 if (obj3) {
14181 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14182 if (!SWIG_IsOK(ecode7)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14184 }
14185 arg7 = static_cast< byte >(val7);
14186 }
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14190 wxPyEndAllowThreads(__tstate);
14191 if (PyErr_Occurred()) SWIG_fail;
14192 }
14193 {
14194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14195 }
14196 if (SWIG_IsTmpObj(res2)) {
14197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14198 } else {
14199 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14201 }
14202 if (SWIG_IsTmpObj(res3)) {
14203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14204 } else {
14205 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14207 }
14208 if (SWIG_IsTmpObj(res4)) {
14209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14210 } else {
14211 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14213 }
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj = 0;
14222 wxImage *arg1 = (wxImage *) 0 ;
14223 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14224 bool result;
14225 void *argp1 = 0 ;
14226 int res1 = 0 ;
14227 unsigned char val2 ;
14228 int ecode2 = 0 ;
14229 PyObject * obj0 = 0 ;
14230 PyObject * obj1 = 0 ;
14231 char * kwnames[] = {
14232 (char *) "self",(char *) "threshold", NULL
14233 };
14234
14235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14237 if (!SWIG_IsOK(res1)) {
14238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14239 }
14240 arg1 = reinterpret_cast< wxImage * >(argp1);
14241 if (obj1) {
14242 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14243 if (!SWIG_IsOK(ecode2)) {
14244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14245 }
14246 arg2 = static_cast< byte >(val2);
14247 }
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 {
14255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14256 }
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj = 0;
14265 wxImage *arg1 = (wxImage *) 0 ;
14266 byte arg2 ;
14267 byte arg3 ;
14268 byte arg4 ;
14269 bool result;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 unsigned char val2 ;
14273 int ecode2 = 0 ;
14274 unsigned char val3 ;
14275 int ecode3 = 0 ;
14276 unsigned char val4 ;
14277 int ecode4 = 0 ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 PyObject * obj2 = 0 ;
14281 PyObject * obj3 = 0 ;
14282 char * kwnames[] = {
14283 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14284 };
14285
14286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14288 if (!SWIG_IsOK(res1)) {
14289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14290 }
14291 arg1 = reinterpret_cast< wxImage * >(argp1);
14292 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14293 if (!SWIG_IsOK(ecode2)) {
14294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14295 }
14296 arg2 = static_cast< byte >(val2);
14297 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14298 if (!SWIG_IsOK(ecode3)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14300 }
14301 arg3 = static_cast< byte >(val3);
14302 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14303 if (!SWIG_IsOK(ecode4)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14305 }
14306 arg4 = static_cast< byte >(val4);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14315 }
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj = 0;
14324 wxImage *arg1 = (wxImage *) 0 ;
14325 wxImage *arg2 = 0 ;
14326 byte arg3 ;
14327 byte arg4 ;
14328 byte arg5 ;
14329 bool result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 void *argp2 = 0 ;
14333 int res2 = 0 ;
14334 unsigned char val3 ;
14335 int ecode3 = 0 ;
14336 unsigned char val4 ;
14337 int ecode4 = 0 ;
14338 unsigned char val5 ;
14339 int ecode5 = 0 ;
14340 PyObject * obj0 = 0 ;
14341 PyObject * obj1 = 0 ;
14342 PyObject * obj2 = 0 ;
14343 PyObject * obj3 = 0 ;
14344 PyObject * obj4 = 0 ;
14345 char * kwnames[] = {
14346 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14347 };
14348
14349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14353 }
14354 arg1 = reinterpret_cast< wxImage * >(argp1);
14355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14356 if (!SWIG_IsOK(res2)) {
14357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14358 }
14359 if (!argp2) {
14360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14361 }
14362 arg2 = reinterpret_cast< wxImage * >(argp2);
14363 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14364 if (!SWIG_IsOK(ecode3)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14366 }
14367 arg3 = static_cast< byte >(val3);
14368 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14369 if (!SWIG_IsOK(ecode4)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14371 }
14372 arg4 = static_cast< byte >(val4);
14373 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14374 if (!SWIG_IsOK(ecode5)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14376 }
14377 arg5 = static_cast< byte >(val5);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj = 0;
14395 wxString *arg1 = 0 ;
14396 bool result;
14397 bool temp1 = false ;
14398 PyObject * obj0 = 0 ;
14399 char * kwnames[] = {
14400 (char *) "filename", NULL
14401 };
14402
14403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14404 {
14405 arg1 = wxString_in_helper(obj0);
14406 if (arg1 == NULL) SWIG_fail;
14407 temp1 = true;
14408 }
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14417 }
14418 {
14419 if (temp1)
14420 delete arg1;
14421 }
14422 return resultobj;
14423 fail:
14424 {
14425 if (temp1)
14426 delete arg1;
14427 }
14428 return NULL;
14429 }
14430
14431
14432 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj = 0;
14434 wxString *arg1 = 0 ;
14435 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14436 int result;
14437 bool temp1 = false ;
14438 long val2 ;
14439 int ecode2 = 0 ;
14440 PyObject * obj0 = 0 ;
14441 PyObject * obj1 = 0 ;
14442 char * kwnames[] = {
14443 (char *) "filename",(char *) "type", NULL
14444 };
14445
14446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14447 {
14448 arg1 = wxString_in_helper(obj0);
14449 if (arg1 == NULL) SWIG_fail;
14450 temp1 = true;
14451 }
14452 if (obj1) {
14453 ecode2 = SWIG_AsVal_long(obj1, &val2);
14454 if (!SWIG_IsOK(ecode2)) {
14455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14456 }
14457 arg2 = static_cast< long >(val2);
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_From_int(static_cast< int >(result));
14466 {
14467 if (temp1)
14468 delete arg1;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (temp1)
14474 delete arg1;
14475 }
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj = 0;
14482 wxImage *arg1 = (wxImage *) 0 ;
14483 wxString *arg2 = 0 ;
14484 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14485 int arg4 = (int) -1 ;
14486 bool result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 bool temp2 = false ;
14490 long val3 ;
14491 int ecode3 = 0 ;
14492 int val4 ;
14493 int ecode4 = 0 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 PyObject * obj3 = 0 ;
14498 char * kwnames[] = {
14499 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14500 };
14501
14502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14504 if (!SWIG_IsOK(res1)) {
14505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14506 }
14507 arg1 = reinterpret_cast< wxImage * >(argp1);
14508 {
14509 arg2 = wxString_in_helper(obj1);
14510 if (arg2 == NULL) SWIG_fail;
14511 temp2 = true;
14512 }
14513 if (obj2) {
14514 ecode3 = SWIG_AsVal_long(obj2, &val3);
14515 if (!SWIG_IsOK(ecode3)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14517 }
14518 arg3 = static_cast< long >(val3);
14519 }
14520 if (obj3) {
14521 ecode4 = SWIG_AsVal_int(obj3, &val4);
14522 if (!SWIG_IsOK(ecode4)) {
14523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14524 }
14525 arg4 = static_cast< int >(val4);
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14530 wxPyEndAllowThreads(__tstate);
14531 if (PyErr_Occurred()) SWIG_fail;
14532 }
14533 {
14534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14535 }
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 return resultobj;
14541 fail:
14542 {
14543 if (temp2)
14544 delete arg2;
14545 }
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj = 0;
14552 wxImage *arg1 = (wxImage *) 0 ;
14553 wxString *arg2 = 0 ;
14554 wxString *arg3 = 0 ;
14555 int arg4 = (int) -1 ;
14556 bool result;
14557 void *argp1 = 0 ;
14558 int res1 = 0 ;
14559 bool temp2 = false ;
14560 bool temp3 = false ;
14561 int val4 ;
14562 int ecode4 = 0 ;
14563 PyObject * obj0 = 0 ;
14564 PyObject * obj1 = 0 ;
14565 PyObject * obj2 = 0 ;
14566 PyObject * obj3 = 0 ;
14567 char * kwnames[] = {
14568 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14569 };
14570
14571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14575 }
14576 arg1 = reinterpret_cast< wxImage * >(argp1);
14577 {
14578 arg2 = wxString_in_helper(obj1);
14579 if (arg2 == NULL) SWIG_fail;
14580 temp2 = true;
14581 }
14582 {
14583 arg3 = wxString_in_helper(obj2);
14584 if (arg3 == NULL) SWIG_fail;
14585 temp3 = true;
14586 }
14587 if (obj3) {
14588 ecode4 = SWIG_AsVal_int(obj3, &val4);
14589 if (!SWIG_IsOK(ecode4)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14591 }
14592 arg4 = static_cast< int >(val4);
14593 }
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14597 wxPyEndAllowThreads(__tstate);
14598 if (PyErr_Occurred()) SWIG_fail;
14599 }
14600 {
14601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14602 }
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 {
14608 if (temp3)
14609 delete arg3;
14610 }
14611 return resultobj;
14612 fail:
14613 {
14614 if (temp2)
14615 delete arg2;
14616 }
14617 {
14618 if (temp3)
14619 delete arg3;
14620 }
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14626 PyObject *resultobj = 0;
14627 wxImage *arg1 = (wxImage *) 0 ;
14628 wxString *arg2 = 0 ;
14629 int arg3 ;
14630 bool result;
14631 void *argp1 = 0 ;
14632 int res1 = 0 ;
14633 bool temp2 = false ;
14634 int val3 ;
14635 int ecode3 = 0 ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 PyObject * obj2 = 0 ;
14639 char * kwnames[] = {
14640 (char *) "self",(char *) "name",(char *) "type", NULL
14641 };
14642
14643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14645 if (!SWIG_IsOK(res1)) {
14646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14647 }
14648 arg1 = reinterpret_cast< wxImage * >(argp1);
14649 {
14650 arg2 = wxString_in_helper(obj1);
14651 if (arg2 == NULL) SWIG_fail;
14652 temp2 = true;
14653 }
14654 ecode3 = SWIG_AsVal_int(obj2, &val3);
14655 if (!SWIG_IsOK(ecode3)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14657 }
14658 arg3 = static_cast< int >(val3);
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 {
14669 if (temp2)
14670 delete arg2;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj = 0;
14684 wxImage *arg1 = (wxImage *) 0 ;
14685 wxString *arg2 = 0 ;
14686 wxString *arg3 = 0 ;
14687 bool result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 bool temp2 = false ;
14691 bool temp3 = false ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 PyObject * obj2 = 0 ;
14695 char * kwnames[] = {
14696 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14697 };
14698
14699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14701 if (!SWIG_IsOK(res1)) {
14702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14703 }
14704 arg1 = reinterpret_cast< wxImage * >(argp1);
14705 {
14706 arg2 = wxString_in_helper(obj1);
14707 if (arg2 == NULL) SWIG_fail;
14708 temp2 = true;
14709 }
14710 {
14711 arg3 = wxString_in_helper(obj2);
14712 if (arg3 == NULL) SWIG_fail;
14713 temp3 = true;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 {
14722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14723 }
14724 {
14725 if (temp2)
14726 delete arg2;
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 {
14739 if (temp3)
14740 delete arg3;
14741 }
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj = 0;
14748 wxInputStream *arg1 = 0 ;
14749 bool result;
14750 wxPyInputStream *temp1 ;
14751 bool created1 ;
14752 PyObject * obj0 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "stream", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14758 {
14759 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14760 arg1 = temp1->m_wxis;
14761 created1 = false;
14762 } else {
14763 PyErr_Clear(); // clear the failure of the wxPyConvert above
14764 arg1 = wxPyCBInputStream_create(obj0, false);
14765 if (arg1 == NULL) {
14766 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14767 SWIG_fail;
14768 }
14769 created1 = true;
14770 }
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)wxImage::CanRead(*arg1);
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 {
14779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14780 }
14781 {
14782 if (created1) delete arg1;
14783 }
14784 return resultobj;
14785 fail:
14786 {
14787 if (created1) delete arg1;
14788 }
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14794 PyObject *resultobj = 0;
14795 wxImage *arg1 = (wxImage *) 0 ;
14796 wxInputStream *arg2 = 0 ;
14797 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14798 int arg4 = (int) -1 ;
14799 bool result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 wxPyInputStream *temp2 ;
14803 bool created2 ;
14804 long val3 ;
14805 int ecode3 = 0 ;
14806 int val4 ;
14807 int ecode4 = 0 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 PyObject * obj2 = 0 ;
14811 PyObject * obj3 = 0 ;
14812 char * kwnames[] = {
14813 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14814 };
14815
14816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14818 if (!SWIG_IsOK(res1)) {
14819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14820 }
14821 arg1 = reinterpret_cast< wxImage * >(argp1);
14822 {
14823 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14824 arg2 = temp2->m_wxis;
14825 created2 = false;
14826 } else {
14827 PyErr_Clear(); // clear the failure of the wxPyConvert above
14828 arg2 = wxPyCBInputStream_create(obj1, false);
14829 if (arg2 == NULL) {
14830 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14831 SWIG_fail;
14832 }
14833 created2 = true;
14834 }
14835 }
14836 if (obj2) {
14837 ecode3 = SWIG_AsVal_long(obj2, &val3);
14838 if (!SWIG_IsOK(ecode3)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14840 }
14841 arg3 = static_cast< long >(val3);
14842 }
14843 if (obj3) {
14844 ecode4 = SWIG_AsVal_int(obj3, &val4);
14845 if (!SWIG_IsOK(ecode4)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14847 }
14848 arg4 = static_cast< int >(val4);
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (created2) delete arg2;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (created2) delete arg2;
14866 }
14867 return NULL;
14868 }
14869
14870
14871 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj = 0;
14873 wxImage *arg1 = (wxImage *) 0 ;
14874 wxInputStream *arg2 = 0 ;
14875 wxString *arg3 = 0 ;
14876 int arg4 = (int) -1 ;
14877 bool result;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 wxPyInputStream *temp2 ;
14881 bool created2 ;
14882 bool temp3 = false ;
14883 int val4 ;
14884 int ecode4 = 0 ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 PyObject * obj2 = 0 ;
14888 PyObject * obj3 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImage * >(argp1);
14899 {
14900 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14901 arg2 = temp2->m_wxis;
14902 created2 = false;
14903 } else {
14904 PyErr_Clear(); // clear the failure of the wxPyConvert above
14905 arg2 = wxPyCBInputStream_create(obj1, false);
14906 if (arg2 == NULL) {
14907 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14908 SWIG_fail;
14909 }
14910 created2 = true;
14911 }
14912 }
14913 {
14914 arg3 = wxString_in_helper(obj2);
14915 if (arg3 == NULL) SWIG_fail;
14916 temp3 = true;
14917 }
14918 if (obj3) {
14919 ecode4 = SWIG_AsVal_int(obj3, &val4);
14920 if (!SWIG_IsOK(ecode4)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14922 }
14923 arg4 = static_cast< int >(val4);
14924 }
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14928 wxPyEndAllowThreads(__tstate);
14929 if (PyErr_Occurred()) SWIG_fail;
14930 }
14931 {
14932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14933 }
14934 {
14935 if (created2) delete arg2;
14936 }
14937 {
14938 if (temp3)
14939 delete arg3;
14940 }
14941 return resultobj;
14942 fail:
14943 {
14944 if (created2) delete arg2;
14945 }
14946 {
14947 if (temp3)
14948 delete arg3;
14949 }
14950 return NULL;
14951 }
14952
14953
14954 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14955 PyObject *resultobj = 0;
14956 wxImage *arg1 = (wxImage *) 0 ;
14957 bool result;
14958 void *argp1 = 0 ;
14959 int res1 = 0 ;
14960 PyObject *swig_obj[1] ;
14961
14962 if (!args) SWIG_fail;
14963 swig_obj[0] = args;
14964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14965 if (!SWIG_IsOK(res1)) {
14966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14967 }
14968 arg1 = reinterpret_cast< wxImage * >(argp1);
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->Ok();
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxImage *arg1 = (wxImage *) 0 ;
14987 int result;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 PyObject *swig_obj[1] ;
14991
14992 if (!args) SWIG_fail;
14993 swig_obj[0] = args;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14997 }
14998 arg1 = reinterpret_cast< wxImage * >(argp1);
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (int)(arg1)->GetWidth();
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 resultobj = SWIG_From_int(static_cast< int >(result));
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxImage *arg1 = (wxImage *) 0 ;
15015 int result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15025 }
15026 arg1 = reinterpret_cast< wxImage * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (int)(arg1)->GetHeight();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxImage *arg1 = (wxImage *) 0 ;
15043 wxSize result;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 PyObject *swig_obj[1] ;
15047
15048 if (!args) SWIG_fail;
15049 swig_obj[0] = args;
15050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15051 if (!SWIG_IsOK(res1)) {
15052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15053 }
15054 arg1 = reinterpret_cast< wxImage * >(argp1);
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = wxImage_GetSize(arg1);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj = 0;
15070 wxImage *arg1 = (wxImage *) 0 ;
15071 wxRect *arg2 = 0 ;
15072 SwigValueWrapper<wxImage > result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 wxRect temp2 ;
15076 PyObject * obj0 = 0 ;
15077 PyObject * obj1 = 0 ;
15078 char * kwnames[] = {
15079 (char *) "self",(char *) "rect", NULL
15080 };
15081
15082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15084 if (!SWIG_IsOK(res1)) {
15085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15086 }
15087 arg1 = reinterpret_cast< wxImage * >(argp1);
15088 {
15089 arg2 = &temp2;
15090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj = 0;
15107 wxImage *arg1 = (wxImage *) 0 ;
15108 wxSize *arg2 = 0 ;
15109 wxPoint *arg3 = 0 ;
15110 int arg4 = (int) -1 ;
15111 int arg5 = (int) -1 ;
15112 int arg6 = (int) -1 ;
15113 SwigValueWrapper<wxImage > result;
15114 void *argp1 = 0 ;
15115 int res1 = 0 ;
15116 wxSize temp2 ;
15117 wxPoint temp3 ;
15118 int val4 ;
15119 int ecode4 = 0 ;
15120 int val5 ;
15121 int ecode5 = 0 ;
15122 int val6 ;
15123 int ecode6 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 PyObject * obj3 = 0 ;
15128 PyObject * obj4 = 0 ;
15129 PyObject * obj5 = 0 ;
15130 char * kwnames[] = {
15131 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15132 };
15133
15134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15136 if (!SWIG_IsOK(res1)) {
15137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15138 }
15139 arg1 = reinterpret_cast< wxImage * >(argp1);
15140 {
15141 arg2 = &temp2;
15142 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15143 }
15144 {
15145 arg3 = &temp3;
15146 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15147 }
15148 if (obj3) {
15149 ecode4 = SWIG_AsVal_int(obj3, &val4);
15150 if (!SWIG_IsOK(ecode4)) {
15151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15152 }
15153 arg4 = static_cast< int >(val4);
15154 }
15155 if (obj4) {
15156 ecode5 = SWIG_AsVal_int(obj4, &val5);
15157 if (!SWIG_IsOK(ecode5)) {
15158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15159 }
15160 arg5 = static_cast< int >(val5);
15161 }
15162 if (obj5) {
15163 ecode6 = SWIG_AsVal_int(obj5, &val6);
15164 if (!SWIG_IsOK(ecode6)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15166 }
15167 arg6 = static_cast< int >(val6);
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183 PyObject *resultobj = 0;
15184 wxImage *arg1 = (wxImage *) 0 ;
15185 SwigValueWrapper<wxImage > result;
15186 void *argp1 = 0 ;
15187 int res1 = 0 ;
15188 PyObject *swig_obj[1] ;
15189
15190 if (!args) SWIG_fail;
15191 swig_obj[0] = args;
15192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15193 if (!SWIG_IsOK(res1)) {
15194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15195 }
15196 arg1 = reinterpret_cast< wxImage * >(argp1);
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (arg1)->Copy();
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = 0;
15212 wxImage *arg1 = (wxImage *) 0 ;
15213 wxImage *arg2 = 0 ;
15214 int arg3 ;
15215 int arg4 ;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 void *argp2 = 0 ;
15219 int res2 = 0 ;
15220 int val3 ;
15221 int ecode3 = 0 ;
15222 int val4 ;
15223 int ecode4 = 0 ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 PyObject * obj2 = 0 ;
15227 PyObject * obj3 = 0 ;
15228 char * kwnames[] = {
15229 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15230 };
15231
15232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15236 }
15237 arg1 = reinterpret_cast< wxImage * >(argp1);
15238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15239 if (!SWIG_IsOK(res2)) {
15240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15241 }
15242 if (!argp2) {
15243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15244 }
15245 arg2 = reinterpret_cast< wxImage * >(argp2);
15246 ecode3 = SWIG_AsVal_int(obj2, &val3);
15247 if (!SWIG_IsOK(ecode3)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15249 }
15250 arg3 = static_cast< int >(val3);
15251 ecode4 = SWIG_AsVal_int(obj3, &val4);
15252 if (!SWIG_IsOK(ecode4)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15254 }
15255 arg4 = static_cast< int >(val4);
15256 {
15257 PyThreadState* __tstate = wxPyBeginAllowThreads();
15258 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15259 wxPyEndAllowThreads(__tstate);
15260 if (PyErr_Occurred()) SWIG_fail;
15261 }
15262 resultobj = SWIG_Py_Void();
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15270 PyObject *resultobj = 0;
15271 wxImage *arg1 = (wxImage *) 0 ;
15272 PyObject *result = 0 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 PyObject *swig_obj[1] ;
15276
15277 if (!args) SWIG_fail;
15278 swig_obj[0] = args;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage * >(argp1);
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = (PyObject *)wxImage_GetData(arg1);
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = result;
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj = 0;
15299 wxImage *arg1 = (wxImage *) 0 ;
15300 buffer arg2 ;
15301 int arg3 ;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "data", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage * >(argp1);
15316 {
15317 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15318 }
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 wxImage_SetData(arg1,arg2,arg3);
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_GetDataBuffer(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_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15345 }
15346 arg1 = reinterpret_cast< wxImage * >(argp1);
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (PyObject *)wxImage_GetDataBuffer(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_SetDataBuffer(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_SetDataBuffer",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_SetDataBuffer" "', 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_SetDataBuffer(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_GetAlphaData(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_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15408 }
15409 arg1 = reinterpret_cast< wxImage * >(argp1);
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (PyObject *)wxImage_GetAlphaData(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_SetAlphaData(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 *) "alpha", NULL
15434 };
15435
15436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",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_SetAlphaData" "', 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_SetAlphaData(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_GetAlphaBuffer(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_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15471 }
15472 arg1 = reinterpret_cast< wxImage * >(argp1);
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (PyObject *)wxImage_GetAlphaBuffer(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_SetAlphaBuffer(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_SetAlphaBuffer",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_SetAlphaBuffer" "', 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_SetAlphaBuffer(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_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15522 PyObject *resultobj = 0;
15523 wxImage *arg1 = (wxImage *) 0 ;
15524 byte arg2 ;
15525 byte arg3 ;
15526 byte arg4 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 unsigned char val2 ;
15530 int ecode2 = 0 ;
15531 unsigned char val3 ;
15532 int ecode3 = 0 ;
15533 unsigned char val4 ;
15534 int ecode4 = 0 ;
15535 PyObject * obj0 = 0 ;
15536 PyObject * obj1 = 0 ;
15537 PyObject * obj2 = 0 ;
15538 PyObject * obj3 = 0 ;
15539 char * kwnames[] = {
15540 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15541 };
15542
15543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15545 if (!SWIG_IsOK(res1)) {
15546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15547 }
15548 arg1 = reinterpret_cast< wxImage * >(argp1);
15549 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15550 if (!SWIG_IsOK(ecode2)) {
15551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15552 }
15553 arg2 = static_cast< byte >(val2);
15554 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15555 if (!SWIG_IsOK(ecode3)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15557 }
15558 arg3 = static_cast< byte >(val3);
15559 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15560 if (!SWIG_IsOK(ecode4)) {
15561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15562 }
15563 arg4 = static_cast< byte >(val4);
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 (arg1)->SetMaskColour(arg2,arg3,arg4);
15567 wxPyEndAllowThreads(__tstate);
15568 if (PyErr_Occurred()) SWIG_fail;
15569 }
15570 resultobj = SWIG_Py_Void();
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15578 PyObject *resultobj = 0;
15579 wxImage *arg1 = (wxImage *) 0 ;
15580 byte *arg2 = (byte *) 0 ;
15581 byte *arg3 = (byte *) 0 ;
15582 byte *arg4 = (byte *) 0 ;
15583 void *argp1 = 0 ;
15584 int res1 = 0 ;
15585 byte temp2 ;
15586 int res2 = SWIG_TMPOBJ ;
15587 byte temp3 ;
15588 int res3 = SWIG_TMPOBJ ;
15589 byte temp4 ;
15590 int res4 = SWIG_TMPOBJ ;
15591 PyObject *swig_obj[1] ;
15592
15593 arg2 = &temp2;
15594 arg3 = &temp3;
15595 arg4 = &temp4;
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = SWIG_Py_Void();
15610 if (SWIG_IsTmpObj(res2)) {
15611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15612 } else {
15613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15615 }
15616 if (SWIG_IsTmpObj(res3)) {
15617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15618 } else {
15619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15621 }
15622 if (SWIG_IsTmpObj(res4)) {
15623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15624 } else {
15625 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635 PyObject *resultobj = 0;
15636 wxImage *arg1 = (wxImage *) 0 ;
15637 byte result;
15638 void *argp1 = 0 ;
15639 int res1 = 0 ;
15640 PyObject *swig_obj[1] ;
15641
15642 if (!args) SWIG_fail;
15643 swig_obj[0] = args;
15644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15645 if (!SWIG_IsOK(res1)) {
15646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15647 }
15648 arg1 = reinterpret_cast< wxImage * >(argp1);
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (byte)(arg1)->GetMaskRed();
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 PyObject *resultobj = 0;
15664 wxImage *arg1 = (wxImage *) 0 ;
15665 byte result;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 PyObject *swig_obj[1] ;
15669
15670 if (!args) SWIG_fail;
15671 swig_obj[0] = args;
15672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15673 if (!SWIG_IsOK(res1)) {
15674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15675 }
15676 arg1 = reinterpret_cast< wxImage * >(argp1);
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (byte)(arg1)->GetMaskGreen();
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15691 PyObject *resultobj = 0;
15692 wxImage *arg1 = (wxImage *) 0 ;
15693 byte result;
15694 void *argp1 = 0 ;
15695 int res1 = 0 ;
15696 PyObject *swig_obj[1] ;
15697
15698 if (!args) SWIG_fail;
15699 swig_obj[0] = args;
15700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15703 }
15704 arg1 = reinterpret_cast< wxImage * >(argp1);
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (byte)(arg1)->GetMaskBlue();
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj = 0;
15720 wxImage *arg1 = (wxImage *) 0 ;
15721 bool arg2 = (bool) true ;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 bool val2 ;
15725 int ecode2 = 0 ;
15726 PyObject * obj0 = 0 ;
15727 PyObject * obj1 = 0 ;
15728 char * kwnames[] = {
15729 (char *) "self",(char *) "mask", NULL
15730 };
15731
15732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15736 }
15737 arg1 = reinterpret_cast< wxImage * >(argp1);
15738 if (obj1) {
15739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15740 if (!SWIG_IsOK(ecode2)) {
15741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15742 }
15743 arg2 = static_cast< bool >(val2);
15744 }
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 (arg1)->SetMask(arg2);
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 resultobj = SWIG_Py_Void();
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15759 PyObject *resultobj = 0;
15760 wxImage *arg1 = (wxImage *) 0 ;
15761 bool result;
15762 void *argp1 = 0 ;
15763 int res1 = 0 ;
15764 PyObject *swig_obj[1] ;
15765
15766 if (!args) SWIG_fail;
15767 swig_obj[0] = args;
15768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15769 if (!SWIG_IsOK(res1)) {
15770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15771 }
15772 arg1 = reinterpret_cast< wxImage * >(argp1);
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 result = (bool)(arg1)->HasMask();
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 {
15780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15781 }
15782 return resultobj;
15783 fail:
15784 return NULL;
15785 }
15786
15787
15788 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15789 PyObject *resultobj = 0;
15790 wxImage *arg1 = (wxImage *) 0 ;
15791 double arg2 ;
15792 wxPoint *arg3 = 0 ;
15793 bool arg4 = (bool) true ;
15794 wxPoint *arg5 = (wxPoint *) NULL ;
15795 SwigValueWrapper<wxImage > result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 double val2 ;
15799 int ecode2 = 0 ;
15800 wxPoint temp3 ;
15801 bool val4 ;
15802 int ecode4 = 0 ;
15803 void *argp5 = 0 ;
15804 int res5 = 0 ;
15805 PyObject * obj0 = 0 ;
15806 PyObject * obj1 = 0 ;
15807 PyObject * obj2 = 0 ;
15808 PyObject * obj3 = 0 ;
15809 PyObject * obj4 = 0 ;
15810 char * kwnames[] = {
15811 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15812 };
15813
15814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 ecode2 = SWIG_AsVal_double(obj1, &val2);
15821 if (!SWIG_IsOK(ecode2)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15823 }
15824 arg2 = static_cast< double >(val2);
15825 {
15826 arg3 = &temp3;
15827 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15828 }
15829 if (obj3) {
15830 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15831 if (!SWIG_IsOK(ecode4)) {
15832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15833 }
15834 arg4 = static_cast< bool >(val4);
15835 }
15836 if (obj4) {
15837 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15838 if (!SWIG_IsOK(res5)) {
15839 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15840 }
15841 arg5 = reinterpret_cast< wxPoint * >(argp5);
15842 }
15843 {
15844 PyThreadState* __tstate = wxPyBeginAllowThreads();
15845 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15846 wxPyEndAllowThreads(__tstate);
15847 if (PyErr_Occurred()) SWIG_fail;
15848 }
15849 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15857 PyObject *resultobj = 0;
15858 wxImage *arg1 = (wxImage *) 0 ;
15859 bool arg2 = (bool) true ;
15860 SwigValueWrapper<wxImage > result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 bool val2 ;
15864 int ecode2 = 0 ;
15865 PyObject * obj0 = 0 ;
15866 PyObject * obj1 = 0 ;
15867 char * kwnames[] = {
15868 (char *) "self",(char *) "clockwise", NULL
15869 };
15870
15871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15873 if (!SWIG_IsOK(res1)) {
15874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15875 }
15876 arg1 = reinterpret_cast< wxImage * >(argp1);
15877 if (obj1) {
15878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15879 if (!SWIG_IsOK(ecode2)) {
15880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15881 }
15882 arg2 = static_cast< bool >(val2);
15883 }
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 result = (arg1)->Rotate90(arg2);
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj = 0;
15899 wxImage *arg1 = (wxImage *) 0 ;
15900 bool arg2 = (bool) true ;
15901 SwigValueWrapper<wxImage > result;
15902 void *argp1 = 0 ;
15903 int res1 = 0 ;
15904 bool val2 ;
15905 int ecode2 = 0 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 char * kwnames[] = {
15909 (char *) "self",(char *) "horizontally", NULL
15910 };
15911
15912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15914 if (!SWIG_IsOK(res1)) {
15915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15916 }
15917 arg1 = reinterpret_cast< wxImage * >(argp1);
15918 if (obj1) {
15919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15920 if (!SWIG_IsOK(ecode2)) {
15921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15922 }
15923 arg2 = static_cast< bool >(val2);
15924 }
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = (arg1)->Mirror(arg2);
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj = 0;
15940 wxImage *arg1 = (wxImage *) 0 ;
15941 byte arg2 ;
15942 byte arg3 ;
15943 byte arg4 ;
15944 byte arg5 ;
15945 byte arg6 ;
15946 byte arg7 ;
15947 void *argp1 = 0 ;
15948 int res1 = 0 ;
15949 unsigned char val2 ;
15950 int ecode2 = 0 ;
15951 unsigned char val3 ;
15952 int ecode3 = 0 ;
15953 unsigned char val4 ;
15954 int ecode4 = 0 ;
15955 unsigned char val5 ;
15956 int ecode5 = 0 ;
15957 unsigned char val6 ;
15958 int ecode6 = 0 ;
15959 unsigned char val7 ;
15960 int ecode7 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 PyObject * obj3 = 0 ;
15965 PyObject * obj4 = 0 ;
15966 PyObject * obj5 = 0 ;
15967 PyObject * obj6 = 0 ;
15968 char * kwnames[] = {
15969 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15970 };
15971
15972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15974 if (!SWIG_IsOK(res1)) {
15975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15976 }
15977 arg1 = reinterpret_cast< wxImage * >(argp1);
15978 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15979 if (!SWIG_IsOK(ecode2)) {
15980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15981 }
15982 arg2 = static_cast< byte >(val2);
15983 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15984 if (!SWIG_IsOK(ecode3)) {
15985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15986 }
15987 arg3 = static_cast< byte >(val3);
15988 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15989 if (!SWIG_IsOK(ecode4)) {
15990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15991 }
15992 arg4 = static_cast< byte >(val4);
15993 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15994 if (!SWIG_IsOK(ecode5)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15996 }
15997 arg5 = static_cast< byte >(val5);
15998 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15999 if (!SWIG_IsOK(ecode6)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16001 }
16002 arg6 = static_cast< byte >(val6);
16003 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16004 if (!SWIG_IsOK(ecode7)) {
16005 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16006 }
16007 arg7 = static_cast< byte >(val7);
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 resultobj = SWIG_Py_Void();
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj = 0;
16023 wxImage *arg1 = (wxImage *) 0 ;
16024 double arg2 = (double) 0.299 ;
16025 double arg3 = (double) 0.587 ;
16026 double arg4 = (double) 0.114 ;
16027 SwigValueWrapper<wxImage > result;
16028 void *argp1 = 0 ;
16029 int res1 = 0 ;
16030 double val2 ;
16031 int ecode2 = 0 ;
16032 double val3 ;
16033 int ecode3 = 0 ;
16034 double val4 ;
16035 int ecode4 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 PyObject * obj2 = 0 ;
16039 PyObject * obj3 = 0 ;
16040 char * kwnames[] = {
16041 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16042 };
16043
16044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16046 if (!SWIG_IsOK(res1)) {
16047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16048 }
16049 arg1 = reinterpret_cast< wxImage * >(argp1);
16050 if (obj1) {
16051 ecode2 = SWIG_AsVal_double(obj1, &val2);
16052 if (!SWIG_IsOK(ecode2)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16054 }
16055 arg2 = static_cast< double >(val2);
16056 }
16057 if (obj2) {
16058 ecode3 = SWIG_AsVal_double(obj2, &val3);
16059 if (!SWIG_IsOK(ecode3)) {
16060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16061 }
16062 arg3 = static_cast< double >(val3);
16063 }
16064 if (obj3) {
16065 ecode4 = SWIG_AsVal_double(obj3, &val4);
16066 if (!SWIG_IsOK(ecode4)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16068 }
16069 arg4 = static_cast< double >(val4);
16070 }
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj = 0;
16086 wxImage *arg1 = (wxImage *) 0 ;
16087 byte arg2 ;
16088 byte arg3 ;
16089 byte arg4 ;
16090 SwigValueWrapper<wxImage > result;
16091 void *argp1 = 0 ;
16092 int res1 = 0 ;
16093 unsigned char val2 ;
16094 int ecode2 = 0 ;
16095 unsigned char val3 ;
16096 int ecode3 = 0 ;
16097 unsigned char 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 *) "r",(char *) "g",(char *) "b", NULL
16105 };
16106
16107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",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_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16111 }
16112 arg1 = reinterpret_cast< wxImage * >(argp1);
16113 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16114 if (!SWIG_IsOK(ecode2)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16116 }
16117 arg2 = static_cast< byte >(val2);
16118 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16119 if (!SWIG_IsOK(ecode3)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16121 }
16122 arg3 = static_cast< byte >(val3);
16123 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16124 if (!SWIG_IsOK(ecode4)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16126 }
16127 arg4 = static_cast< byte >(val4);
16128 {
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj = 0;
16143 wxImage *arg1 = (wxImage *) 0 ;
16144 wxString *arg2 = 0 ;
16145 wxString *arg3 = 0 ;
16146 void *argp1 = 0 ;
16147 int res1 = 0 ;
16148 bool temp2 = false ;
16149 bool temp3 = false ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 PyObject * obj2 = 0 ;
16153 char * kwnames[] = {
16154 (char *) "self",(char *) "name",(char *) "value", NULL
16155 };
16156
16157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16161 }
16162 arg1 = reinterpret_cast< wxImage * >(argp1);
16163 {
16164 arg2 = wxString_in_helper(obj1);
16165 if (arg2 == NULL) SWIG_fail;
16166 temp2 = true;
16167 }
16168 {
16169 arg3 = wxString_in_helper(obj2);
16170 if (arg3 == NULL) SWIG_fail;
16171 temp3 = true;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 resultobj = SWIG_Py_Void();
16180 {
16181 if (temp2)
16182 delete arg2;
16183 }
16184 {
16185 if (temp3)
16186 delete arg3;
16187 }
16188 return resultobj;
16189 fail:
16190 {
16191 if (temp2)
16192 delete arg2;
16193 }
16194 {
16195 if (temp3)
16196 delete arg3;
16197 }
16198 return NULL;
16199 }
16200
16201
16202 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16203 PyObject *resultobj = 0;
16204 wxImage *arg1 = (wxImage *) 0 ;
16205 wxString *arg2 = 0 ;
16206 int arg3 ;
16207 void *argp1 = 0 ;
16208 int res1 = 0 ;
16209 bool temp2 = false ;
16210 int val3 ;
16211 int ecode3 = 0 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 PyObject * obj2 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *) "name",(char *) "value", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16223 }
16224 arg1 = reinterpret_cast< wxImage * >(argp1);
16225 {
16226 arg2 = wxString_in_helper(obj1);
16227 if (arg2 == NULL) SWIG_fail;
16228 temp2 = true;
16229 }
16230 ecode3 = SWIG_AsVal_int(obj2, &val3);
16231 if (!SWIG_IsOK(ecode3)) {
16232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16233 }
16234 arg3 = static_cast< int >(val3);
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 (arg1)->SetOption((wxString const &)*arg2,arg3);
16238 wxPyEndAllowThreads(__tstate);
16239 if (PyErr_Occurred()) SWIG_fail;
16240 }
16241 resultobj = SWIG_Py_Void();
16242 {
16243 if (temp2)
16244 delete arg2;
16245 }
16246 return resultobj;
16247 fail:
16248 {
16249 if (temp2)
16250 delete arg2;
16251 }
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxImage *arg1 = (wxImage *) 0 ;
16259 wxString *arg2 = 0 ;
16260 wxString result;
16261 void *argp1 = 0 ;
16262 int res1 = 0 ;
16263 bool temp2 = false ;
16264 PyObject * obj0 = 0 ;
16265 PyObject * obj1 = 0 ;
16266 char * kwnames[] = {
16267 (char *) "self",(char *) "name", NULL
16268 };
16269
16270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16272 if (!SWIG_IsOK(res1)) {
16273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16274 }
16275 arg1 = reinterpret_cast< wxImage * >(argp1);
16276 {
16277 arg2 = wxString_in_helper(obj1);
16278 if (arg2 == NULL) SWIG_fail;
16279 temp2 = true;
16280 }
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16284 wxPyEndAllowThreads(__tstate);
16285 if (PyErr_Occurred()) SWIG_fail;
16286 }
16287 {
16288 #if wxUSE_UNICODE
16289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16290 #else
16291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16292 #endif
16293 }
16294 {
16295 if (temp2)
16296 delete arg2;
16297 }
16298 return resultobj;
16299 fail:
16300 {
16301 if (temp2)
16302 delete arg2;
16303 }
16304 return NULL;
16305 }
16306
16307
16308 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16309 PyObject *resultobj = 0;
16310 wxImage *arg1 = (wxImage *) 0 ;
16311 wxString *arg2 = 0 ;
16312 int result;
16313 void *argp1 = 0 ;
16314 int res1 = 0 ;
16315 bool temp2 = false ;
16316 PyObject * obj0 = 0 ;
16317 PyObject * obj1 = 0 ;
16318 char * kwnames[] = {
16319 (char *) "self",(char *) "name", NULL
16320 };
16321
16322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16324 if (!SWIG_IsOK(res1)) {
16325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16326 }
16327 arg1 = reinterpret_cast< wxImage * >(argp1);
16328 {
16329 arg2 = wxString_in_helper(obj1);
16330 if (arg2 == NULL) SWIG_fail;
16331 temp2 = true;
16332 }
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 resultobj = SWIG_From_int(static_cast< int >(result));
16340 {
16341 if (temp2)
16342 delete arg2;
16343 }
16344 return resultobj;
16345 fail:
16346 {
16347 if (temp2)
16348 delete arg2;
16349 }
16350 return NULL;
16351 }
16352
16353
16354 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16355 PyObject *resultobj = 0;
16356 wxImage *arg1 = (wxImage *) 0 ;
16357 wxString *arg2 = 0 ;
16358 bool result;
16359 void *argp1 = 0 ;
16360 int res1 = 0 ;
16361 bool temp2 = false ;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 char * kwnames[] = {
16365 (char *) "self",(char *) "name", NULL
16366 };
16367
16368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16370 if (!SWIG_IsOK(res1)) {
16371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16372 }
16373 arg1 = reinterpret_cast< wxImage * >(argp1);
16374 {
16375 arg2 = wxString_in_helper(obj1);
16376 if (arg2 == NULL) SWIG_fail;
16377 temp2 = true;
16378 }
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 {
16386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16387 }
16388 {
16389 if (temp2)
16390 delete arg2;
16391 }
16392 return resultobj;
16393 fail:
16394 {
16395 if (temp2)
16396 delete arg2;
16397 }
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16403 PyObject *resultobj = 0;
16404 wxImage *arg1 = (wxImage *) 0 ;
16405 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16406 unsigned long result;
16407 void *argp1 = 0 ;
16408 int res1 = 0 ;
16409 unsigned long val2 ;
16410 int ecode2 = 0 ;
16411 PyObject * obj0 = 0 ;
16412 PyObject * obj1 = 0 ;
16413 char * kwnames[] = {
16414 (char *) "self",(char *) "stopafter", NULL
16415 };
16416
16417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16419 if (!SWIG_IsOK(res1)) {
16420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16421 }
16422 arg1 = reinterpret_cast< wxImage * >(argp1);
16423 if (obj1) {
16424 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16425 if (!SWIG_IsOK(ecode2)) {
16426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16427 }
16428 arg2 = static_cast< unsigned long >(val2);
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (unsigned long)(arg1)->CountColours(arg2);
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 wxImageHistogram *arg2 = 0 ;
16447 unsigned long result;
16448 void *argp1 = 0 ;
16449 int res1 = 0 ;
16450 void *argp2 = 0 ;
16451 int res2 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 char * kwnames[] = {
16455 (char *) "self",(char *) "h", NULL
16456 };
16457
16458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16462 }
16463 arg1 = reinterpret_cast< wxImage * >(argp1);
16464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16465 if (!SWIG_IsOK(res2)) {
16466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16467 }
16468 if (!argp2) {
16469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16470 }
16471 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16472 {
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16475 wxPyEndAllowThreads(__tstate);
16476 if (PyErr_Occurred()) SWIG_fail;
16477 }
16478 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject * obj0 = 0 ;
16491 char * kwnames[] = {
16492 (char *) "handler", NULL
16493 };
16494
16495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16499 }
16500 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 wxImage::AddHandler(arg1);
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_Py_Void();
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj = 0;
16516 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16517 void *argp1 = 0 ;
16518 int res1 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 char * kwnames[] = {
16521 (char *) "handler", NULL
16522 };
16523
16524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16528 }
16529 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 wxImage::InsertHandler(arg1);
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 resultobj = SWIG_Py_Void();
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj = 0;
16545 wxString *arg1 = 0 ;
16546 bool result;
16547 bool temp1 = false ;
16548 PyObject * obj0 = 0 ;
16549 char * kwnames[] = {
16550 (char *) "name", NULL
16551 };
16552
16553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16554 {
16555 arg1 = wxString_in_helper(obj0);
16556 if (arg1 == NULL) SWIG_fail;
16557 temp1 = true;
16558 }
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 {
16566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16567 }
16568 {
16569 if (temp1)
16570 delete arg1;
16571 }
16572 return resultobj;
16573 fail:
16574 {
16575 if (temp1)
16576 delete arg1;
16577 }
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 PyObject *result = 0 ;
16585
16586 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (PyObject *)wxImage_GetHandlers();
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = result;
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16601 PyObject *resultobj = 0;
16602 wxString result;
16603
16604 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = wxImage::GetImageExtWildcard();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 {
16612 #if wxUSE_UNICODE
16613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16614 #else
16615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16616 #endif
16617 }
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj = 0;
16626 wxImage *arg1 = (wxImage *) 0 ;
16627 int arg2 = (int) -1 ;
16628 wxBitmap result;
16629 void *argp1 = 0 ;
16630 int res1 = 0 ;
16631 int val2 ;
16632 int ecode2 = 0 ;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char * kwnames[] = {
16636 (char *) "self",(char *) "depth", NULL
16637 };
16638
16639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16643 }
16644 arg1 = reinterpret_cast< wxImage * >(argp1);
16645 if (obj1) {
16646 ecode2 = SWIG_AsVal_int(obj1, &val2);
16647 if (!SWIG_IsOK(ecode2)) {
16648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16649 }
16650 arg2 = static_cast< int >(val2);
16651 }
16652 {
16653 if (!wxPyCheckForApp()) SWIG_fail;
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 result = wxImage_ConvertToBitmap(arg1,arg2);
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj = 0;
16668 wxImage *arg1 = (wxImage *) 0 ;
16669 byte arg2 ;
16670 byte arg3 ;
16671 byte arg4 ;
16672 wxBitmap result;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 unsigned char val2 ;
16676 int ecode2 = 0 ;
16677 unsigned char val3 ;
16678 int ecode3 = 0 ;
16679 unsigned char val4 ;
16680 int ecode4 = 0 ;
16681 PyObject * obj0 = 0 ;
16682 PyObject * obj1 = 0 ;
16683 PyObject * obj2 = 0 ;
16684 PyObject * obj3 = 0 ;
16685 char * kwnames[] = {
16686 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16687 };
16688
16689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16693 }
16694 arg1 = reinterpret_cast< wxImage * >(argp1);
16695 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16696 if (!SWIG_IsOK(ecode2)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16698 }
16699 arg2 = static_cast< byte >(val2);
16700 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16701 if (!SWIG_IsOK(ecode3)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16703 }
16704 arg3 = static_cast< byte >(val3);
16705 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16706 if (!SWIG_IsOK(ecode4)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16708 }
16709 arg4 = static_cast< byte >(val4);
16710 {
16711 if (!wxPyCheckForApp()) SWIG_fail;
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj = 0;
16726 wxImage *arg1 = (wxImage *) 0 ;
16727 double arg2 ;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 double val2 ;
16731 int ecode2 = 0 ;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 char * kwnames[] = {
16735 (char *) "self",(char *) "angle", NULL
16736 };
16737
16738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16740 if (!SWIG_IsOK(res1)) {
16741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16742 }
16743 arg1 = reinterpret_cast< wxImage * >(argp1);
16744 ecode2 = SWIG_AsVal_double(obj1, &val2);
16745 if (!SWIG_IsOK(ecode2)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16747 }
16748 arg2 = static_cast< double >(val2);
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 (arg1)->RotateHue(arg2);
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 resultobj = SWIG_Py_Void();
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj = 0;
16764 wxImage_RGBValue arg1 ;
16765 wxImage_HSVValue result;
16766 void *argp1 ;
16767 int res1 = 0 ;
16768 PyObject * obj0 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "rgb", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16774 {
16775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16778 }
16779 if (!argp1) {
16780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16781 } else {
16782 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16783 arg1 = *temp;
16784 if (SWIG_IsNewObj(res1)) delete temp;
16785 }
16786 }
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 result = wxImage::RGBtoHSV(arg1);
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = 0;
16802 wxImage_HSVValue arg1 ;
16803 wxImage_RGBValue result;
16804 void *argp1 ;
16805 int res1 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 char * kwnames[] = {
16808 (char *) "hsv", NULL
16809 };
16810
16811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16812 {
16813 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16814 if (!SWIG_IsOK(res1)) {
16815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16816 }
16817 if (!argp1) {
16818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16819 } else {
16820 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16821 arg1 = *temp;
16822 if (SWIG_IsNewObj(res1)) delete temp;
16823 }
16824 }
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = wxImage::HSVtoRGB(arg1);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16839 PyObject *obj;
16840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16841 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16842 return SWIG_Py_Void();
16843 }
16844
16845 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16846 return SWIG_Python_InitShadowInstance(args);
16847 }
16848
16849 SWIGINTERN int NullImage_set(PyObject *) {
16850 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16851 return 1;
16852 }
16853
16854
16855 SWIGINTERN PyObject *NullImage_get(void) {
16856 PyObject *pyobj = 0;
16857
16858 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16859 return pyobj;
16860 }
16861
16862
16863 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16864 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16865 return 1;
16866 }
16867
16868
16869 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16870 PyObject *pyobj = 0;
16871
16872 {
16873 #if wxUSE_UNICODE
16874 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16875 #else
16876 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16877 #endif
16878 }
16879 return pyobj;
16880 }
16881
16882
16883 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16884 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16885 return 1;
16886 }
16887
16888
16889 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16890 PyObject *pyobj = 0;
16891
16892 {
16893 #if wxUSE_UNICODE
16894 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16895 #else
16896 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16897 #endif
16898 }
16899 return pyobj;
16900 }
16901
16902
16903 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16904 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16905 return 1;
16906 }
16907
16908
16909 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16910 PyObject *pyobj = 0;
16911
16912 {
16913 #if wxUSE_UNICODE
16914 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16915 #else
16916 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16917 #endif
16918 }
16919 return pyobj;
16920 }
16921
16922
16923 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16924 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16925 return 1;
16926 }
16927
16928
16929 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16930 PyObject *pyobj = 0;
16931
16932 {
16933 #if wxUSE_UNICODE
16934 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16935 #else
16936 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16937 #endif
16938 }
16939 return pyobj;
16940 }
16941
16942
16943 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16944 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16945 return 1;
16946 }
16947
16948
16949 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16950 PyObject *pyobj = 0;
16951
16952 {
16953 #if wxUSE_UNICODE
16954 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16955 #else
16956 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16957 #endif
16958 }
16959 return pyobj;
16960 }
16961
16962
16963 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16964 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16965 return 1;
16966 }
16967
16968
16969 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16970 PyObject *pyobj = 0;
16971
16972 {
16973 #if wxUSE_UNICODE
16974 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16975 #else
16976 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16977 #endif
16978 }
16979 return pyobj;
16980 }
16981
16982
16983 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16984 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16985 return 1;
16986 }
16987
16988
16989 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16990 PyObject *pyobj = 0;
16991
16992 {
16993 #if wxUSE_UNICODE
16994 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16995 #else
16996 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16997 #endif
16998 }
16999 return pyobj;
17000 }
17001
17002
17003 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17004 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17005 return 1;
17006 }
17007
17008
17009 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17010 PyObject *pyobj = 0;
17011
17012 {
17013 #if wxUSE_UNICODE
17014 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17015 #else
17016 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17017 #endif
17018 }
17019 return pyobj;
17020 }
17021
17022
17023 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17024 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17025 return 1;
17026 }
17027
17028
17029 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17030 PyObject *pyobj = 0;
17031
17032 {
17033 #if wxUSE_UNICODE
17034 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17035 #else
17036 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17037 #endif
17038 }
17039 return pyobj;
17040 }
17041
17042
17043 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17044 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17045 return 1;
17046 }
17047
17048
17049 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17050 PyObject *pyobj = 0;
17051
17052 {
17053 #if wxUSE_UNICODE
17054 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17055 #else
17056 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17057 #endif
17058 }
17059 return pyobj;
17060 }
17061
17062
17063 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17064 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17065 return 1;
17066 }
17067
17068
17069 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17070 PyObject *pyobj = 0;
17071
17072 {
17073 #if wxUSE_UNICODE
17074 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17075 #else
17076 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17077 #endif
17078 }
17079 return pyobj;
17080 }
17081
17082
17083 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17084 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17085 return 1;
17086 }
17087
17088
17089 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17090 PyObject *pyobj = 0;
17091
17092 {
17093 #if wxUSE_UNICODE
17094 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17095 #else
17096 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17097 #endif
17098 }
17099 return pyobj;
17100 }
17101
17102
17103 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17104 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17105 return 1;
17106 }
17107
17108
17109 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17110 PyObject *pyobj = 0;
17111
17112 {
17113 #if wxUSE_UNICODE
17114 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17115 #else
17116 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17117 #endif
17118 }
17119 return pyobj;
17120 }
17121
17122
17123 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17124 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17125 return 1;
17126 }
17127
17128
17129 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17130 PyObject *pyobj = 0;
17131
17132 {
17133 #if wxUSE_UNICODE
17134 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17135 #else
17136 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17137 #endif
17138 }
17139 return pyobj;
17140 }
17141
17142
17143 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17144 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17145 return 1;
17146 }
17147
17148
17149 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17150 PyObject *pyobj = 0;
17151
17152 {
17153 #if wxUSE_UNICODE
17154 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17155 #else
17156 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17157 #endif
17158 }
17159 return pyobj;
17160 }
17161
17162
17163 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17164 PyObject *resultobj = 0;
17165 wxBMPHandler *result = 0 ;
17166
17167 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (wxBMPHandler *)new wxBMPHandler();
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17182 PyObject *obj;
17183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17184 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17185 return SWIG_Py_Void();
17186 }
17187
17188 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17189 return SWIG_Python_InitShadowInstance(args);
17190 }
17191
17192 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17193 PyObject *resultobj = 0;
17194 wxICOHandler *result = 0 ;
17195
17196 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17197 {
17198 PyThreadState* __tstate = wxPyBeginAllowThreads();
17199 result = (wxICOHandler *)new wxICOHandler();
17200 wxPyEndAllowThreads(__tstate);
17201 if (PyErr_Occurred()) SWIG_fail;
17202 }
17203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17211 PyObject *obj;
17212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17213 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17214 return SWIG_Py_Void();
17215 }
17216
17217 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17218 return SWIG_Python_InitShadowInstance(args);
17219 }
17220
17221 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17222 PyObject *resultobj = 0;
17223 wxCURHandler *result = 0 ;
17224
17225 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (wxCURHandler *)new wxCURHandler();
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17233 return resultobj;
17234 fail:
17235 return NULL;
17236 }
17237
17238
17239 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *obj;
17241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17242 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17243 return SWIG_Py_Void();
17244 }
17245
17246 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17247 return SWIG_Python_InitShadowInstance(args);
17248 }
17249
17250 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17251 PyObject *resultobj = 0;
17252 wxANIHandler *result = 0 ;
17253
17254 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (wxANIHandler *)new wxANIHandler();
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17269 PyObject *obj;
17270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17271 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17272 return SWIG_Py_Void();
17273 }
17274
17275 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276 return SWIG_Python_InitShadowInstance(args);
17277 }
17278
17279 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17280 PyObject *resultobj = 0;
17281 wxPNGHandler *result = 0 ;
17282
17283 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17284 {
17285 PyThreadState* __tstate = wxPyBeginAllowThreads();
17286 result = (wxPNGHandler *)new wxPNGHandler();
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17291 return resultobj;
17292 fail:
17293 return NULL;
17294 }
17295
17296
17297 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17298 PyObject *obj;
17299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17300 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17301 return SWIG_Py_Void();
17302 }
17303
17304 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305 return SWIG_Python_InitShadowInstance(args);
17306 }
17307
17308 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17309 PyObject *resultobj = 0;
17310 wxGIFHandler *result = 0 ;
17311
17312 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (wxGIFHandler *)new wxGIFHandler();
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 PyObject *obj;
17328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17329 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17330 return SWIG_Py_Void();
17331 }
17332
17333 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 return SWIG_Python_InitShadowInstance(args);
17335 }
17336
17337 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17338 PyObject *resultobj = 0;
17339 wxPCXHandler *result = 0 ;
17340
17341 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (wxPCXHandler *)new wxPCXHandler();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17356 PyObject *obj;
17357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17358 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17359 return SWIG_Py_Void();
17360 }
17361
17362 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 return SWIG_Python_InitShadowInstance(args);
17364 }
17365
17366 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17367 PyObject *resultobj = 0;
17368 wxJPEGHandler *result = 0 ;
17369
17370 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17371 {
17372 PyThreadState* __tstate = wxPyBeginAllowThreads();
17373 result = (wxJPEGHandler *)new wxJPEGHandler();
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *obj;
17386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17387 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17388 return SWIG_Py_Void();
17389 }
17390
17391 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17392 return SWIG_Python_InitShadowInstance(args);
17393 }
17394
17395 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17396 PyObject *resultobj = 0;
17397 wxPNMHandler *result = 0 ;
17398
17399 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (wxPNMHandler *)new wxPNMHandler();
17403 wxPyEndAllowThreads(__tstate);
17404 if (PyErr_Occurred()) SWIG_fail;
17405 }
17406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17407 return resultobj;
17408 fail:
17409 return NULL;
17410 }
17411
17412
17413 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 PyObject *obj;
17415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17416 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17417 return SWIG_Py_Void();
17418 }
17419
17420 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17421 return SWIG_Python_InitShadowInstance(args);
17422 }
17423
17424 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17425 PyObject *resultobj = 0;
17426 wxXPMHandler *result = 0 ;
17427
17428 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (wxXPMHandler *)new wxXPMHandler();
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *obj;
17444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17445 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17446 return SWIG_Py_Void();
17447 }
17448
17449 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 return SWIG_Python_InitShadowInstance(args);
17451 }
17452
17453 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17454 PyObject *resultobj = 0;
17455 wxTIFFHandler *result = 0 ;
17456
17457 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (wxTIFFHandler *)new wxTIFFHandler();
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 PyObject *obj;
17473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17474 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17475 return SWIG_Py_Void();
17476 }
17477
17478 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17479 return SWIG_Python_InitShadowInstance(args);
17480 }
17481
17482 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj = 0;
17484 wxImage *arg1 = 0 ;
17485 wxImage *arg2 = 0 ;
17486 int arg3 = (int) 236 ;
17487 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17488 bool result;
17489 void *argp1 = 0 ;
17490 int res1 = 0 ;
17491 void *argp2 = 0 ;
17492 int res2 = 0 ;
17493 int val3 ;
17494 int ecode3 = 0 ;
17495 int val4 ;
17496 int ecode4 = 0 ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 PyObject * obj2 = 0 ;
17500 PyObject * obj3 = 0 ;
17501 char * kwnames[] = {
17502 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17503 };
17504
17505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17506 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17507 if (!SWIG_IsOK(res1)) {
17508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17509 }
17510 if (!argp1) {
17511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17512 }
17513 arg1 = reinterpret_cast< wxImage * >(argp1);
17514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17515 if (!SWIG_IsOK(res2)) {
17516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17517 }
17518 if (!argp2) {
17519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17520 }
17521 arg2 = reinterpret_cast< wxImage * >(argp2);
17522 if (obj2) {
17523 ecode3 = SWIG_AsVal_int(obj2, &val3);
17524 if (!SWIG_IsOK(ecode3)) {
17525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17526 }
17527 arg3 = static_cast< int >(val3);
17528 }
17529 if (obj3) {
17530 ecode4 = SWIG_AsVal_int(obj3, &val4);
17531 if (!SWIG_IsOK(ecode4)) {
17532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17533 }
17534 arg4 = static_cast< int >(val4);
17535 }
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17544 }
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 PyObject *obj;
17553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17554 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17555 return SWIG_Py_Void();
17556 }
17557
17558 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 PyObject *resultobj = 0;
17560 wxEvtHandler *result = 0 ;
17561
17562 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17563 {
17564 PyThreadState* __tstate = wxPyBeginAllowThreads();
17565 result = (wxEvtHandler *)new wxEvtHandler();
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 PyObject *resultobj = 0;
17578 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17579 wxEvtHandler *result = 0 ;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 PyObject *swig_obj[1] ;
17583
17584 if (!args) SWIG_fail;
17585 swig_obj[0] = args;
17586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17587 if (!SWIG_IsOK(res1)) {
17588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17589 }
17590 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = wxPyMake_wxObject(result, 0);
17599 }
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17609 wxEvtHandler *result = 0 ;
17610 void *argp1 = 0 ;
17611 int res1 = 0 ;
17612 PyObject *swig_obj[1] ;
17613
17614 if (!args) SWIG_fail;
17615 swig_obj[0] = args;
17616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17617 if (!SWIG_IsOK(res1)) {
17618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17619 }
17620 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17621 {
17622 PyThreadState* __tstate = wxPyBeginAllowThreads();
17623 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = wxPyMake_wxObject(result, 0);
17629 }
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj = 0;
17638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17639 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17640 void *argp1 = 0 ;
17641 int res1 = 0 ;
17642 void *argp2 = 0 ;
17643 int res2 = 0 ;
17644 PyObject * obj0 = 0 ;
17645 PyObject * obj1 = 0 ;
17646 char * kwnames[] = {
17647 (char *) "self",(char *) "handler", NULL
17648 };
17649
17650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17652 if (!SWIG_IsOK(res1)) {
17653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17654 }
17655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17657 if (!SWIG_IsOK(res2)) {
17658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17659 }
17660 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 (arg1)->SetNextHandler(arg2);
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 resultobj = SWIG_Py_Void();
17668 return resultobj;
17669 fail:
17670 return NULL;
17671 }
17672
17673
17674 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17675 PyObject *resultobj = 0;
17676 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17677 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17678 void *argp1 = 0 ;
17679 int res1 = 0 ;
17680 void *argp2 = 0 ;
17681 int res2 = 0 ;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 char * kwnames[] = {
17685 (char *) "self",(char *) "handler", NULL
17686 };
17687
17688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17690 if (!SWIG_IsOK(res1)) {
17691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17692 }
17693 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17695 if (!SWIG_IsOK(res2)) {
17696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17697 }
17698 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 (arg1)->SetPreviousHandler(arg2);
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_Py_Void();
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17714 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17715 bool result;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 PyObject *swig_obj[1] ;
17719
17720 if (!args) SWIG_fail;
17721 swig_obj[0] = args;
17722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17725 }
17726 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->GetEvtHandlerEnabled();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17735 }
17736 return resultobj;
17737 fail:
17738 return NULL;
17739 }
17740
17741
17742 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17743 PyObject *resultobj = 0;
17744 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17745 bool arg2 ;
17746 void *argp1 = 0 ;
17747 int res1 = 0 ;
17748 bool val2 ;
17749 int ecode2 = 0 ;
17750 PyObject * obj0 = 0 ;
17751 PyObject * obj1 = 0 ;
17752 char * kwnames[] = {
17753 (char *) "self",(char *) "enabled", NULL
17754 };
17755
17756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17758 if (!SWIG_IsOK(res1)) {
17759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17760 }
17761 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17763 if (!SWIG_IsOK(ecode2)) {
17764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17765 }
17766 arg2 = static_cast< bool >(val2);
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 (arg1)->SetEvtHandlerEnabled(arg2);
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 resultobj = SWIG_Py_Void();
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj = 0;
17782 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17783 wxEvent *arg2 = 0 ;
17784 bool result;
17785 void *argp1 = 0 ;
17786 int res1 = 0 ;
17787 void *argp2 = 0 ;
17788 int res2 = 0 ;
17789 PyObject * obj0 = 0 ;
17790 PyObject * obj1 = 0 ;
17791 char * kwnames[] = {
17792 (char *) "self",(char *) "event", NULL
17793 };
17794
17795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17797 if (!SWIG_IsOK(res1)) {
17798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17799 }
17800 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17802 if (!SWIG_IsOK(res2)) {
17803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17804 }
17805 if (!argp2) {
17806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17807 }
17808 arg2 = reinterpret_cast< wxEvent * >(argp2);
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)(arg1)->ProcessEvent(*arg2);
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj = 0;
17826 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17827 wxEvent *arg2 = 0 ;
17828 void *argp1 = 0 ;
17829 int res1 = 0 ;
17830 void *argp2 = 0 ;
17831 int res2 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char * kwnames[] = {
17835 (char *) "self",(char *) "event", NULL
17836 };
17837
17838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17842 }
17843 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17845 if (!SWIG_IsOK(res2)) {
17846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17847 }
17848 if (!argp2) {
17849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17850 }
17851 arg2 = reinterpret_cast< wxEvent * >(argp2);
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 (arg1)->AddPendingEvent(*arg2);
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 resultobj = SWIG_Py_Void();
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17866 PyObject *resultobj = 0;
17867 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 PyObject *swig_obj[1] ;
17871
17872 if (!args) SWIG_fail;
17873 swig_obj[0] = args;
17874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17875 if (!SWIG_IsOK(res1)) {
17876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17877 }
17878 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 (arg1)->ProcessPendingEvents();
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 resultobj = SWIG_Py_Void();
17886 return resultobj;
17887 fail:
17888 return NULL;
17889 }
17890
17891
17892 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17893 PyObject *resultobj = 0;
17894 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17895 int arg2 ;
17896 int arg3 ;
17897 int arg4 ;
17898 PyObject *arg5 = (PyObject *) 0 ;
17899 void *argp1 = 0 ;
17900 int res1 = 0 ;
17901 int val2 ;
17902 int ecode2 = 0 ;
17903 int val3 ;
17904 int ecode3 = 0 ;
17905 int val4 ;
17906 int ecode4 = 0 ;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909 PyObject * obj2 = 0 ;
17910 PyObject * obj3 = 0 ;
17911 PyObject * obj4 = 0 ;
17912 char * kwnames[] = {
17913 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17914 };
17915
17916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17918 if (!SWIG_IsOK(res1)) {
17919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17920 }
17921 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17922 ecode2 = SWIG_AsVal_int(obj1, &val2);
17923 if (!SWIG_IsOK(ecode2)) {
17924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17925 }
17926 arg2 = static_cast< int >(val2);
17927 ecode3 = SWIG_AsVal_int(obj2, &val3);
17928 if (!SWIG_IsOK(ecode3)) {
17929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17930 }
17931 arg3 = static_cast< int >(val3);
17932 ecode4 = SWIG_AsVal_int(obj3, &val4);
17933 if (!SWIG_IsOK(ecode4)) {
17934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17935 }
17936 arg4 = static_cast< int >(val4);
17937 arg5 = obj4;
17938 {
17939 PyThreadState* __tstate = wxPyBeginAllowThreads();
17940 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 resultobj = SWIG_Py_Void();
17945 return resultobj;
17946 fail:
17947 return NULL;
17948 }
17949
17950
17951 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17952 PyObject *resultobj = 0;
17953 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17954 int arg2 ;
17955 int arg3 = (int) -1 ;
17956 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17957 bool result;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 int val2 ;
17961 int ecode2 = 0 ;
17962 int val3 ;
17963 int ecode3 = 0 ;
17964 int val4 ;
17965 int ecode4 = 0 ;
17966 PyObject * obj0 = 0 ;
17967 PyObject * obj1 = 0 ;
17968 PyObject * obj2 = 0 ;
17969 PyObject * obj3 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17978 }
17979 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17980 ecode2 = SWIG_AsVal_int(obj1, &val2);
17981 if (!SWIG_IsOK(ecode2)) {
17982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17983 }
17984 arg2 = static_cast< int >(val2);
17985 if (obj2) {
17986 ecode3 = SWIG_AsVal_int(obj2, &val3);
17987 if (!SWIG_IsOK(ecode3)) {
17988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17989 }
17990 arg3 = static_cast< int >(val3);
17991 }
17992 if (obj3) {
17993 ecode4 = SWIG_AsVal_int(obj3, &val4);
17994 if (!SWIG_IsOK(ecode4)) {
17995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17996 }
17997 arg4 = static_cast< wxEventType >(val4);
17998 }
17999 {
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18002 wxPyEndAllowThreads(__tstate);
18003 if (PyErr_Occurred()) SWIG_fail;
18004 }
18005 {
18006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj = 0;
18016 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18017 PyObject *arg2 = (PyObject *) 0 ;
18018 bool arg3 = (bool) true ;
18019 void *argp1 = 0 ;
18020 int res1 = 0 ;
18021 bool val3 ;
18022 int ecode3 = 0 ;
18023 PyObject * obj0 = 0 ;
18024 PyObject * obj1 = 0 ;
18025 PyObject * obj2 = 0 ;
18026 char * kwnames[] = {
18027 (char *) "self",(char *) "_self",(char *) "incref", NULL
18028 };
18029
18030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18032 if (!SWIG_IsOK(res1)) {
18033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18034 }
18035 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18036 arg2 = obj1;
18037 if (obj2) {
18038 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18039 if (!SWIG_IsOK(ecode3)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18041 }
18042 arg3 = static_cast< bool >(val3);
18043 }
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 resultobj = SWIG_Py_Void();
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18058 PyObject *obj;
18059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18060 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18061 return SWIG_Py_Void();
18062 }
18063
18064 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 return SWIG_Python_InitShadowInstance(args);
18066 }
18067
18068 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18069 PyObject *resultobj = 0;
18070 wxEventType result;
18071
18072 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (wxEventType)wxNewEventType();
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_From_int(static_cast< int >(result));
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxEvent *arg1 = (wxEvent *) 0 ;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 PyObject *swig_obj[1] ;
18092
18093 if (!args) SWIG_fail;
18094 swig_obj[0] = args;
18095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18096 if (!SWIG_IsOK(res1)) {
18097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18098 }
18099 arg1 = reinterpret_cast< wxEvent * >(argp1);
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 delete arg1;
18103
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_Py_Void();
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18115 PyObject *resultobj = 0;
18116 wxEvent *arg1 = (wxEvent *) 0 ;
18117 wxEventType arg2 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 int val2 ;
18121 int ecode2 = 0 ;
18122 PyObject * obj0 = 0 ;
18123 PyObject * obj1 = 0 ;
18124 char * kwnames[] = {
18125 (char *) "self",(char *) "typ", NULL
18126 };
18127
18128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18130 if (!SWIG_IsOK(res1)) {
18131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18132 }
18133 arg1 = reinterpret_cast< wxEvent * >(argp1);
18134 ecode2 = SWIG_AsVal_int(obj1, &val2);
18135 if (!SWIG_IsOK(ecode2)) {
18136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18137 }
18138 arg2 = static_cast< wxEventType >(val2);
18139 {
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 (arg1)->SetEventType(arg2);
18142 wxPyEndAllowThreads(__tstate);
18143 if (PyErr_Occurred()) SWIG_fail;
18144 }
18145 resultobj = SWIG_Py_Void();
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18153 PyObject *resultobj = 0;
18154 wxEvent *arg1 = (wxEvent *) 0 ;
18155 wxEventType result;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 PyObject *swig_obj[1] ;
18159
18160 if (!args) SWIG_fail;
18161 swig_obj[0] = args;
18162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvent * >(argp1);
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 resultobj = SWIG_From_int(static_cast< int >(result));
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *resultobj = 0;
18182 wxEvent *arg1 = (wxEvent *) 0 ;
18183 wxObject *result = 0 ;
18184 void *argp1 = 0 ;
18185 int res1 = 0 ;
18186 PyObject *swig_obj[1] ;
18187
18188 if (!args) SWIG_fail;
18189 swig_obj[0] = args;
18190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18191 if (!SWIG_IsOK(res1)) {
18192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18193 }
18194 arg1 = reinterpret_cast< wxEvent * >(argp1);
18195 {
18196 PyThreadState* __tstate = wxPyBeginAllowThreads();
18197 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18198 wxPyEndAllowThreads(__tstate);
18199 if (PyErr_Occurred()) SWIG_fail;
18200 }
18201 {
18202 resultobj = wxPyMake_wxObject(result, (bool)0);
18203 }
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj = 0;
18212 wxEvent *arg1 = (wxEvent *) 0 ;
18213 wxObject *arg2 = (wxObject *) 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 void *argp2 = 0 ;
18217 int res2 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char * kwnames[] = {
18221 (char *) "self",(char *) "obj", NULL
18222 };
18223
18224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18231 if (!SWIG_IsOK(res2)) {
18232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18233 }
18234 arg2 = reinterpret_cast< wxObject * >(argp2);
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 (arg1)->SetEventObject(arg2);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 resultobj = SWIG_Py_Void();
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18249 PyObject *resultobj = 0;
18250 wxEvent *arg1 = (wxEvent *) 0 ;
18251 long result;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 PyObject *swig_obj[1] ;
18255
18256 if (!args) SWIG_fail;
18257 swig_obj[0] = args;
18258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18259 if (!SWIG_IsOK(res1)) {
18260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18261 }
18262 arg1 = reinterpret_cast< wxEvent * >(argp1);
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = SWIG_From_long(static_cast< long >(result));
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj = 0;
18278 wxEvent *arg1 = (wxEvent *) 0 ;
18279 long arg2 = (long) 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 long val2 ;
18283 int ecode2 = 0 ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 char * kwnames[] = {
18287 (char *) "self",(char *) "ts", NULL
18288 };
18289
18290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18292 if (!SWIG_IsOK(res1)) {
18293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18294 }
18295 arg1 = reinterpret_cast< wxEvent * >(argp1);
18296 if (obj1) {
18297 ecode2 = SWIG_AsVal_long(obj1, &val2);
18298 if (!SWIG_IsOK(ecode2)) {
18299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18300 }
18301 arg2 = static_cast< long >(val2);
18302 }
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 (arg1)->SetTimestamp(arg2);
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = SWIG_Py_Void();
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18317 PyObject *resultobj = 0;
18318 wxEvent *arg1 = (wxEvent *) 0 ;
18319 int result;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 PyObject *swig_obj[1] ;
18323
18324 if (!args) SWIG_fail;
18325 swig_obj[0] = args;
18326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18327 if (!SWIG_IsOK(res1)) {
18328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18329 }
18330 arg1 = reinterpret_cast< wxEvent * >(argp1);
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (int)((wxEvent const *)arg1)->GetId();
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 resultobj = SWIG_From_int(static_cast< int >(result));
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj = 0;
18346 wxEvent *arg1 = (wxEvent *) 0 ;
18347 int arg2 ;
18348 void *argp1 = 0 ;
18349 int res1 = 0 ;
18350 int val2 ;
18351 int ecode2 = 0 ;
18352 PyObject * obj0 = 0 ;
18353 PyObject * obj1 = 0 ;
18354 char * kwnames[] = {
18355 (char *) "self",(char *) "Id", NULL
18356 };
18357
18358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18360 if (!SWIG_IsOK(res1)) {
18361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18362 }
18363 arg1 = reinterpret_cast< wxEvent * >(argp1);
18364 ecode2 = SWIG_AsVal_int(obj1, &val2);
18365 if (!SWIG_IsOK(ecode2)) {
18366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18367 }
18368 arg2 = static_cast< int >(val2);
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 (arg1)->SetId(arg2);
18372 wxPyEndAllowThreads(__tstate);
18373 if (PyErr_Occurred()) SWIG_fail;
18374 }
18375 resultobj = SWIG_Py_Void();
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18383 PyObject *resultobj = 0;
18384 wxEvent *arg1 = (wxEvent *) 0 ;
18385 bool result;
18386 void *argp1 = 0 ;
18387 int res1 = 0 ;
18388 PyObject *swig_obj[1] ;
18389
18390 if (!args) SWIG_fail;
18391 swig_obj[0] = args;
18392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18393 if (!SWIG_IsOK(res1)) {
18394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18395 }
18396 arg1 = reinterpret_cast< wxEvent * >(argp1);
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 {
18404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj = 0;
18414 wxEvent *arg1 = (wxEvent *) 0 ;
18415 bool arg2 = (bool) true ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 bool val2 ;
18419 int ecode2 = 0 ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 char * kwnames[] = {
18423 (char *) "self",(char *) "skip", NULL
18424 };
18425
18426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18428 if (!SWIG_IsOK(res1)) {
18429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18430 }
18431 arg1 = reinterpret_cast< wxEvent * >(argp1);
18432 if (obj1) {
18433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18434 if (!SWIG_IsOK(ecode2)) {
18435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18436 }
18437 arg2 = static_cast< bool >(val2);
18438 }
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 (arg1)->Skip(arg2);
18442 wxPyEndAllowThreads(__tstate);
18443 if (PyErr_Occurred()) SWIG_fail;
18444 }
18445 resultobj = SWIG_Py_Void();
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18453 PyObject *resultobj = 0;
18454 wxEvent *arg1 = (wxEvent *) 0 ;
18455 bool result;
18456 void *argp1 = 0 ;
18457 int res1 = 0 ;
18458 PyObject *swig_obj[1] ;
18459
18460 if (!args) SWIG_fail;
18461 swig_obj[0] = args;
18462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18463 if (!SWIG_IsOK(res1)) {
18464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18465 }
18466 arg1 = reinterpret_cast< wxEvent * >(argp1);
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 {
18474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18475 }
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 wxEvent *arg1 = (wxEvent *) 0 ;
18485 bool result;
18486 void *argp1 = 0 ;
18487 int res1 = 0 ;
18488 PyObject *swig_obj[1] ;
18489
18490 if (!args) SWIG_fail;
18491 swig_obj[0] = args;
18492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18493 if (!SWIG_IsOK(res1)) {
18494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18495 }
18496 arg1 = reinterpret_cast< wxEvent * >(argp1);
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 {
18504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18505 }
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 int result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (int)(arg1)->StopPropagation();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 resultobj = SWIG_From_int(static_cast< int >(result));
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj = 0;
18542 wxEvent *arg1 = (wxEvent *) 0 ;
18543 int arg2 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 int val2 ;
18547 int ecode2 = 0 ;
18548 PyObject * obj0 = 0 ;
18549 PyObject * obj1 = 0 ;
18550 char * kwnames[] = {
18551 (char *) "self",(char *) "propagationLevel", NULL
18552 };
18553
18554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18558 }
18559 arg1 = reinterpret_cast< wxEvent * >(argp1);
18560 ecode2 = SWIG_AsVal_int(obj1, &val2);
18561 if (!SWIG_IsOK(ecode2)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18563 }
18564 arg2 = static_cast< int >(val2);
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->ResumePropagation(arg2);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_Py_Void();
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18579 PyObject *resultobj = 0;
18580 wxEvent *arg1 = (wxEvent *) 0 ;
18581 wxEvent *result = 0 ;
18582 void *argp1 = 0 ;
18583 int res1 = 0 ;
18584 PyObject *swig_obj[1] ;
18585
18586 if (!args) SWIG_fail;
18587 swig_obj[0] = args;
18588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18589 if (!SWIG_IsOK(res1)) {
18590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18591 }
18592 arg1 = reinterpret_cast< wxEvent * >(argp1);
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (wxEvent *)(arg1)->Clone();
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 PyObject *obj;
18608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18609 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18610 return SWIG_Py_Void();
18611 }
18612
18613 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj = 0;
18615 wxEvent *arg1 = 0 ;
18616 wxPropagationDisabler *result = 0 ;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 PyObject * obj0 = 0 ;
18620 char * kwnames[] = {
18621 (char *) "event", NULL
18622 };
18623
18624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18625 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18626 if (!SWIG_IsOK(res1)) {
18627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18628 }
18629 if (!argp1) {
18630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18631 }
18632 arg1 = reinterpret_cast< wxEvent * >(argp1);
18633 {
18634 PyThreadState* __tstate = wxPyBeginAllowThreads();
18635 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18636 wxPyEndAllowThreads(__tstate);
18637 if (PyErr_Occurred()) SWIG_fail;
18638 }
18639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18640 return resultobj;
18641 fail:
18642 return NULL;
18643 }
18644
18645
18646 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18647 PyObject *resultobj = 0;
18648 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18658 }
18659 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 delete arg1;
18663
18664 wxPyEndAllowThreads(__tstate);
18665 if (PyErr_Occurred()) SWIG_fail;
18666 }
18667 resultobj = SWIG_Py_Void();
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18675 PyObject *obj;
18676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18677 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18678 return SWIG_Py_Void();
18679 }
18680
18681 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18682 return SWIG_Python_InitShadowInstance(args);
18683 }
18684
18685 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18686 PyObject *resultobj = 0;
18687 wxEvent *arg1 = 0 ;
18688 wxPropagateOnce *result = 0 ;
18689 void *argp1 = 0 ;
18690 int res1 = 0 ;
18691 PyObject * obj0 = 0 ;
18692 char * kwnames[] = {
18693 (char *) "event", NULL
18694 };
18695
18696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18697 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18698 if (!SWIG_IsOK(res1)) {
18699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18700 }
18701 if (!argp1) {
18702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18703 }
18704 arg1 = reinterpret_cast< wxEvent * >(argp1);
18705 {
18706 PyThreadState* __tstate = wxPyBeginAllowThreads();
18707 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18719 PyObject *resultobj = 0;
18720 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18721 void *argp1 = 0 ;
18722 int res1 = 0 ;
18723 PyObject *swig_obj[1] ;
18724
18725 if (!args) SWIG_fail;
18726 swig_obj[0] = args;
18727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18728 if (!SWIG_IsOK(res1)) {
18729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18730 }
18731 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 delete arg1;
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 resultobj = SWIG_Py_Void();
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18747 PyObject *obj;
18748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18749 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18750 return SWIG_Py_Void();
18751 }
18752
18753 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 return SWIG_Python_InitShadowInstance(args);
18755 }
18756
18757 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj = 0;
18759 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18760 int arg2 = (int) 0 ;
18761 wxCommandEvent *result = 0 ;
18762 int val1 ;
18763 int ecode1 = 0 ;
18764 int val2 ;
18765 int ecode2 = 0 ;
18766 PyObject * obj0 = 0 ;
18767 PyObject * obj1 = 0 ;
18768 char * kwnames[] = {
18769 (char *) "commandType",(char *) "winid", NULL
18770 };
18771
18772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18773 if (obj0) {
18774 ecode1 = SWIG_AsVal_int(obj0, &val1);
18775 if (!SWIG_IsOK(ecode1)) {
18776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18777 }
18778 arg1 = static_cast< wxEventType >(val1);
18779 }
18780 if (obj1) {
18781 ecode2 = SWIG_AsVal_int(obj1, &val2);
18782 if (!SWIG_IsOK(ecode2)) {
18783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18784 }
18785 arg2 = static_cast< int >(val2);
18786 }
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18801 PyObject *resultobj = 0;
18802 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18803 int result;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject *swig_obj[1] ;
18807
18808 if (!args) SWIG_fail;
18809 swig_obj[0] = args;
18810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18811 if (!SWIG_IsOK(res1)) {
18812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18813 }
18814 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 resultobj = SWIG_From_int(static_cast< int >(result));
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj = 0;
18830 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18831 wxString *arg2 = 0 ;
18832 void *argp1 = 0 ;
18833 int res1 = 0 ;
18834 bool temp2 = false ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char * kwnames[] = {
18838 (char *) "self",(char *) "s", NULL
18839 };
18840
18841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18845 }
18846 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18847 {
18848 arg2 = wxString_in_helper(obj1);
18849 if (arg2 == NULL) SWIG_fail;
18850 temp2 = true;
18851 }
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 (arg1)->SetString((wxString const &)*arg2);
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 resultobj = SWIG_Py_Void();
18859 {
18860 if (temp2)
18861 delete arg2;
18862 }
18863 return resultobj;
18864 fail:
18865 {
18866 if (temp2)
18867 delete arg2;
18868 }
18869 return NULL;
18870 }
18871
18872
18873 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18874 PyObject *resultobj = 0;
18875 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18876 wxString result;
18877 void *argp1 = 0 ;
18878 int res1 = 0 ;
18879 PyObject *swig_obj[1] ;
18880
18881 if (!args) SWIG_fail;
18882 swig_obj[0] = args;
18883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18884 if (!SWIG_IsOK(res1)) {
18885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18886 }
18887 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18888 {
18889 PyThreadState* __tstate = wxPyBeginAllowThreads();
18890 result = ((wxCommandEvent const *)arg1)->GetString();
18891 wxPyEndAllowThreads(__tstate);
18892 if (PyErr_Occurred()) SWIG_fail;
18893 }
18894 {
18895 #if wxUSE_UNICODE
18896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18897 #else
18898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18899 #endif
18900 }
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18910 bool result;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18920 }
18921 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 {
18929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18930 }
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18938 PyObject *resultobj = 0;
18939 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18940 bool result;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 PyObject *swig_obj[1] ;
18944
18945 if (!args) SWIG_fail;
18946 swig_obj[0] = args;
18947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18948 if (!SWIG_IsOK(res1)) {
18949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18950 }
18951 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 {
18959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18960 }
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj = 0;
18969 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18970 long arg2 ;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 long val2 ;
18974 int ecode2 = 0 ;
18975 PyObject * obj0 = 0 ;
18976 PyObject * obj1 = 0 ;
18977 char * kwnames[] = {
18978 (char *) "self",(char *) "extraLong", NULL
18979 };
18980
18981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18985 }
18986 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18987 ecode2 = SWIG_AsVal_long(obj1, &val2);
18988 if (!SWIG_IsOK(ecode2)) {
18989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18990 }
18991 arg2 = static_cast< long >(val2);
18992 {
18993 PyThreadState* __tstate = wxPyBeginAllowThreads();
18994 (arg1)->SetExtraLong(arg2);
18995 wxPyEndAllowThreads(__tstate);
18996 if (PyErr_Occurred()) SWIG_fail;
18997 }
18998 resultobj = SWIG_Py_Void();
18999 return resultobj;
19000 fail:
19001 return NULL;
19002 }
19003
19004
19005 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006 PyObject *resultobj = 0;
19007 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19008 long result;
19009 void *argp1 = 0 ;
19010 int res1 = 0 ;
19011 PyObject *swig_obj[1] ;
19012
19013 if (!args) SWIG_fail;
19014 swig_obj[0] = args;
19015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19018 }
19019 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_From_long(static_cast< long >(result));
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = 0;
19035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19036 int arg2 ;
19037 void *argp1 = 0 ;
19038 int res1 = 0 ;
19039 int val2 ;
19040 int ecode2 = 0 ;
19041 PyObject * obj0 = 0 ;
19042 PyObject * obj1 = 0 ;
19043 char * kwnames[] = {
19044 (char *) "self",(char *) "i", NULL
19045 };
19046
19047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 ecode2 = SWIG_AsVal_int(obj1, &val2);
19054 if (!SWIG_IsOK(ecode2)) {
19055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19056 }
19057 arg2 = static_cast< int >(val2);
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 (arg1)->SetInt(arg2);
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_Py_Void();
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19072 PyObject *resultobj = 0;
19073 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19074 long result;
19075 void *argp1 = 0 ;
19076 int res1 = 0 ;
19077 PyObject *swig_obj[1] ;
19078
19079 if (!args) SWIG_fail;
19080 swig_obj[0] = args;
19081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19082 if (!SWIG_IsOK(res1)) {
19083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19084 }
19085 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19086 {
19087 PyThreadState* __tstate = wxPyBeginAllowThreads();
19088 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 resultobj = SWIG_From_long(static_cast< long >(result));
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19100 PyObject *resultobj = 0;
19101 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19102 PyObject *result = 0 ;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 PyObject *swig_obj[1] ;
19106
19107 if (!args) SWIG_fail;
19108 swig_obj[0] = args;
19109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19112 }
19113 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = result;
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 PyObject *arg2 = (PyObject *) 0 ;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject * obj0 = 0 ;
19134 PyObject * obj1 = 0 ;
19135 char * kwnames[] = {
19136 (char *) "self",(char *) "clientData", NULL
19137 };
19138
19139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19141 if (!SWIG_IsOK(res1)) {
19142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19143 }
19144 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19145 arg2 = obj1;
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 wxCommandEvent_SetClientData(arg1,arg2);
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 resultobj = SWIG_Py_Void();
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19162 wxEvent *result = 0 ;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19172 }
19173 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19188 PyObject *obj;
19189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19190 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19191 return SWIG_Py_Void();
19192 }
19193
19194 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19195 return SWIG_Python_InitShadowInstance(args);
19196 }
19197
19198 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19199 PyObject *resultobj = 0;
19200 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19201 int arg2 = (int) 0 ;
19202 wxNotifyEvent *result = 0 ;
19203 int val1 ;
19204 int ecode1 = 0 ;
19205 int val2 ;
19206 int ecode2 = 0 ;
19207 PyObject * obj0 = 0 ;
19208 PyObject * obj1 = 0 ;
19209 char * kwnames[] = {
19210 (char *) "commandType",(char *) "winid", NULL
19211 };
19212
19213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19214 if (obj0) {
19215 ecode1 = SWIG_AsVal_int(obj0, &val1);
19216 if (!SWIG_IsOK(ecode1)) {
19217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19218 }
19219 arg1 = static_cast< wxEventType >(val1);
19220 }
19221 if (obj1) {
19222 ecode2 = SWIG_AsVal_int(obj1, &val2);
19223 if (!SWIG_IsOK(ecode2)) {
19224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19225 }
19226 arg2 = static_cast< int >(val2);
19227 }
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19244 void *argp1 = 0 ;
19245 int res1 = 0 ;
19246 PyObject *swig_obj[1] ;
19247
19248 if (!args) SWIG_fail;
19249 swig_obj[0] = args;
19250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19251 if (!SWIG_IsOK(res1)) {
19252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19253 }
19254 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19255 {
19256 PyThreadState* __tstate = wxPyBeginAllowThreads();
19257 (arg1)->Veto();
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 resultobj = SWIG_Py_Void();
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19269 PyObject *resultobj = 0;
19270 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19271 void *argp1 = 0 ;
19272 int res1 = 0 ;
19273 PyObject *swig_obj[1] ;
19274
19275 if (!args) SWIG_fail;
19276 swig_obj[0] = args;
19277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19278 if (!SWIG_IsOK(res1)) {
19279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19280 }
19281 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 (arg1)->Allow();
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 resultobj = SWIG_Py_Void();
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19296 PyObject *resultobj = 0;
19297 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19298 bool result;
19299 void *argp1 = 0 ;
19300 int res1 = 0 ;
19301 PyObject *swig_obj[1] ;
19302
19303 if (!args) SWIG_fail;
19304 swig_obj[0] = args;
19305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19306 if (!SWIG_IsOK(res1)) {
19307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19308 }
19309 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (bool)(arg1)->IsAllowed();
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 {
19317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19318 }
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 PyObject *obj;
19327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19328 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19329 return SWIG_Py_Void();
19330 }
19331
19332 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 return SWIG_Python_InitShadowInstance(args);
19334 }
19335
19336 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19337 PyObject *resultobj = 0;
19338 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19339 int arg2 = (int) 0 ;
19340 int arg3 = (int) 0 ;
19341 int arg4 = (int) 0 ;
19342 wxScrollEvent *result = 0 ;
19343 int val1 ;
19344 int ecode1 = 0 ;
19345 int val2 ;
19346 int ecode2 = 0 ;
19347 int val3 ;
19348 int ecode3 = 0 ;
19349 int val4 ;
19350 int ecode4 = 0 ;
19351 PyObject * obj0 = 0 ;
19352 PyObject * obj1 = 0 ;
19353 PyObject * obj2 = 0 ;
19354 PyObject * obj3 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19360 if (obj0) {
19361 ecode1 = SWIG_AsVal_int(obj0, &val1);
19362 if (!SWIG_IsOK(ecode1)) {
19363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19364 }
19365 arg1 = static_cast< wxEventType >(val1);
19366 }
19367 if (obj1) {
19368 ecode2 = SWIG_AsVal_int(obj1, &val2);
19369 if (!SWIG_IsOK(ecode2)) {
19370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19371 }
19372 arg2 = static_cast< int >(val2);
19373 }
19374 if (obj2) {
19375 ecode3 = SWIG_AsVal_int(obj2, &val3);
19376 if (!SWIG_IsOK(ecode3)) {
19377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19378 }
19379 arg3 = static_cast< int >(val3);
19380 }
19381 if (obj3) {
19382 ecode4 = SWIG_AsVal_int(obj3, &val4);
19383 if (!SWIG_IsOK(ecode4)) {
19384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19385 }
19386 arg4 = static_cast< int >(val4);
19387 }
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19402 PyObject *resultobj = 0;
19403 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19404 int result;
19405 void *argp1 = 0 ;
19406 int res1 = 0 ;
19407 PyObject *swig_obj[1] ;
19408
19409 if (!args) SWIG_fail;
19410 swig_obj[0] = args;
19411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19412 if (!SWIG_IsOK(res1)) {
19413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19414 }
19415 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_From_int(static_cast< int >(result));
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19430 PyObject *resultobj = 0;
19431 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19432 int result;
19433 void *argp1 = 0 ;
19434 int res1 = 0 ;
19435 PyObject *swig_obj[1] ;
19436
19437 if (!args) SWIG_fail;
19438 swig_obj[0] = args;
19439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19440 if (!SWIG_IsOK(res1)) {
19441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19442 }
19443 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_From_int(static_cast< int >(result));
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj = 0;
19459 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19460 int arg2 ;
19461 void *argp1 = 0 ;
19462 int res1 = 0 ;
19463 int val2 ;
19464 int ecode2 = 0 ;
19465 PyObject * obj0 = 0 ;
19466 PyObject * obj1 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "self",(char *) "orient", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19473 if (!SWIG_IsOK(res1)) {
19474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19475 }
19476 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19477 ecode2 = SWIG_AsVal_int(obj1, &val2);
19478 if (!SWIG_IsOK(ecode2)) {
19479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19480 }
19481 arg2 = static_cast< int >(val2);
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 (arg1)->SetOrientation(arg2);
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 resultobj = SWIG_Py_Void();
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19496 PyObject *resultobj = 0;
19497 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19498 int arg2 ;
19499 void *argp1 = 0 ;
19500 int res1 = 0 ;
19501 int val2 ;
19502 int ecode2 = 0 ;
19503 PyObject * obj0 = 0 ;
19504 PyObject * obj1 = 0 ;
19505 char * kwnames[] = {
19506 (char *) "self",(char *) "pos", NULL
19507 };
19508
19509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19511 if (!SWIG_IsOK(res1)) {
19512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19513 }
19514 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19515 ecode2 = SWIG_AsVal_int(obj1, &val2);
19516 if (!SWIG_IsOK(ecode2)) {
19517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19518 }
19519 arg2 = static_cast< int >(val2);
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 (arg1)->SetPosition(arg2);
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 resultobj = SWIG_Py_Void();
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19534 PyObject *obj;
19535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19536 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19537 return SWIG_Py_Void();
19538 }
19539
19540 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19541 return SWIG_Python_InitShadowInstance(args);
19542 }
19543
19544 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj = 0;
19546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19547 int arg2 = (int) 0 ;
19548 int arg3 = (int) 0 ;
19549 wxScrollWinEvent *result = 0 ;
19550 int val1 ;
19551 int ecode1 = 0 ;
19552 int val2 ;
19553 int ecode2 = 0 ;
19554 int val3 ;
19555 int ecode3 = 0 ;
19556 PyObject * obj0 = 0 ;
19557 PyObject * obj1 = 0 ;
19558 PyObject * obj2 = 0 ;
19559 char * kwnames[] = {
19560 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19561 };
19562
19563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19564 if (obj0) {
19565 ecode1 = SWIG_AsVal_int(obj0, &val1);
19566 if (!SWIG_IsOK(ecode1)) {
19567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19568 }
19569 arg1 = static_cast< wxEventType >(val1);
19570 }
19571 if (obj1) {
19572 ecode2 = SWIG_AsVal_int(obj1, &val2);
19573 if (!SWIG_IsOK(ecode2)) {
19574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19575 }
19576 arg2 = static_cast< int >(val2);
19577 }
19578 if (obj2) {
19579 ecode3 = SWIG_AsVal_int(obj2, &val3);
19580 if (!SWIG_IsOK(ecode3)) {
19581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19582 }
19583 arg3 = static_cast< int >(val3);
19584 }
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19588 wxPyEndAllowThreads(__tstate);
19589 if (PyErr_Occurred()) SWIG_fail;
19590 }
19591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19592 return resultobj;
19593 fail:
19594 return NULL;
19595 }
19596
19597
19598 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19599 PyObject *resultobj = 0;
19600 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19601 int result;
19602 void *argp1 = 0 ;
19603 int res1 = 0 ;
19604 PyObject *swig_obj[1] ;
19605
19606 if (!args) SWIG_fail;
19607 swig_obj[0] = args;
19608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19609 if (!SWIG_IsOK(res1)) {
19610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19611 }
19612 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_From_int(static_cast< int >(result));
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19627 PyObject *resultobj = 0;
19628 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19629 int result;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 PyObject *swig_obj[1] ;
19633
19634 if (!args) SWIG_fail;
19635 swig_obj[0] = args;
19636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19637 if (!SWIG_IsOK(res1)) {
19638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19639 }
19640 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_From_int(static_cast< int >(result));
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj = 0;
19656 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19657 int arg2 ;
19658 void *argp1 = 0 ;
19659 int res1 = 0 ;
19660 int val2 ;
19661 int ecode2 = 0 ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 char * kwnames[] = {
19665 (char *) "self",(char *) "orient", NULL
19666 };
19667
19668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19670 if (!SWIG_IsOK(res1)) {
19671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19672 }
19673 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19674 ecode2 = SWIG_AsVal_int(obj1, &val2);
19675 if (!SWIG_IsOK(ecode2)) {
19676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19677 }
19678 arg2 = static_cast< int >(val2);
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 (arg1)->SetOrientation(arg2);
19682 wxPyEndAllowThreads(__tstate);
19683 if (PyErr_Occurred()) SWIG_fail;
19684 }
19685 resultobj = SWIG_Py_Void();
19686 return resultobj;
19687 fail:
19688 return NULL;
19689 }
19690
19691
19692 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj = 0;
19694 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19695 int arg2 ;
19696 void *argp1 = 0 ;
19697 int res1 = 0 ;
19698 int val2 ;
19699 int ecode2 = 0 ;
19700 PyObject * obj0 = 0 ;
19701 PyObject * obj1 = 0 ;
19702 char * kwnames[] = {
19703 (char *) "self",(char *) "pos", NULL
19704 };
19705
19706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19708 if (!SWIG_IsOK(res1)) {
19709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19710 }
19711 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19712 ecode2 = SWIG_AsVal_int(obj1, &val2);
19713 if (!SWIG_IsOK(ecode2)) {
19714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19715 }
19716 arg2 = static_cast< int >(val2);
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 (arg1)->SetPosition(arg2);
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_Py_Void();
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19731 PyObject *obj;
19732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19733 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19734 return SWIG_Py_Void();
19735 }
19736
19737 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19738 return SWIG_Python_InitShadowInstance(args);
19739 }
19740
19741 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = 0;
19743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19744 wxMouseEvent *result = 0 ;
19745 int val1 ;
19746 int ecode1 = 0 ;
19747 PyObject * obj0 = 0 ;
19748 char * kwnames[] = {
19749 (char *) "mouseType", NULL
19750 };
19751
19752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19753 if (obj0) {
19754 ecode1 = SWIG_AsVal_int(obj0, &val1);
19755 if (!SWIG_IsOK(ecode1)) {
19756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19757 }
19758 arg1 = static_cast< wxEventType >(val1);
19759 }
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 {
19767 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19768 }
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19776 PyObject *resultobj = 0;
19777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19778 bool result;
19779 void *argp1 = 0 ;
19780 int res1 = 0 ;
19781 PyObject *swig_obj[1] ;
19782
19783 if (!args) SWIG_fail;
19784 swig_obj[0] = args;
19785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19786 if (!SWIG_IsOK(res1)) {
19787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19788 }
19789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19790 {
19791 PyThreadState* __tstate = wxPyBeginAllowThreads();
19792 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 {
19797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19798 }
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19808 int arg2 = (int) wxMOUSE_BTN_ANY ;
19809 bool result;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 int val2 ;
19813 int ecode2 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char * kwnames[] = {
19817 (char *) "self",(char *) "but", NULL
19818 };
19819
19820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19824 }
19825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19826 if (obj1) {
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19830 }
19831 arg2 = static_cast< int >(val2);
19832 }
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 {
19840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19841 }
19842 return resultobj;
19843 fail:
19844 return NULL;
19845 }
19846
19847
19848 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19849 PyObject *resultobj = 0;
19850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19851 int arg2 = (int) wxMOUSE_BTN_ANY ;
19852 bool result;
19853 void *argp1 = 0 ;
19854 int res1 = 0 ;
19855 int val2 ;
19856 int ecode2 = 0 ;
19857 PyObject * obj0 = 0 ;
19858 PyObject * obj1 = 0 ;
19859 char * kwnames[] = {
19860 (char *) "self",(char *) "but", NULL
19861 };
19862
19863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19867 }
19868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19869 if (obj1) {
19870 ecode2 = SWIG_AsVal_int(obj1, &val2);
19871 if (!SWIG_IsOK(ecode2)) {
19872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19873 }
19874 arg2 = static_cast< int >(val2);
19875 }
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 {
19883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19884 }
19885 return resultobj;
19886 fail:
19887 return NULL;
19888 }
19889
19890
19891 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19892 PyObject *resultobj = 0;
19893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19894 int arg2 = (int) wxMOUSE_BTN_ANY ;
19895 bool result;
19896 void *argp1 = 0 ;
19897 int res1 = 0 ;
19898 int val2 ;
19899 int ecode2 = 0 ;
19900 PyObject * obj0 = 0 ;
19901 PyObject * obj1 = 0 ;
19902 char * kwnames[] = {
19903 (char *) "self",(char *) "but", NULL
19904 };
19905
19906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19908 if (!SWIG_IsOK(res1)) {
19909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19910 }
19911 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19912 if (obj1) {
19913 ecode2 = SWIG_AsVal_int(obj1, &val2);
19914 if (!SWIG_IsOK(ecode2)) {
19915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19916 }
19917 arg2 = static_cast< int >(val2);
19918 }
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19927 }
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19937 int arg2 ;
19938 bool result;
19939 void *argp1 = 0 ;
19940 int res1 = 0 ;
19941 int val2 ;
19942 int ecode2 = 0 ;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char * kwnames[] = {
19946 (char *) "self",(char *) "button", NULL
19947 };
19948
19949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19953 }
19954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19955 ecode2 = SWIG_AsVal_int(obj1, &val2);
19956 if (!SWIG_IsOK(ecode2)) {
19957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19958 }
19959 arg2 = static_cast< int >(val2);
19960 {
19961 PyThreadState* __tstate = wxPyBeginAllowThreads();
19962 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19963 wxPyEndAllowThreads(__tstate);
19964 if (PyErr_Occurred()) SWIG_fail;
19965 }
19966 {
19967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19968 }
19969 return resultobj;
19970 fail:
19971 return NULL;
19972 }
19973
19974
19975 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj = 0;
19977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19978 int arg2 ;
19979 bool result;
19980 void *argp1 = 0 ;
19981 int res1 = 0 ;
19982 int val2 ;
19983 int ecode2 = 0 ;
19984 PyObject * obj0 = 0 ;
19985 PyObject * obj1 = 0 ;
19986 char * kwnames[] = {
19987 (char *) "self",(char *) "but", NULL
19988 };
19989
19990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19994 }
19995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19996 ecode2 = SWIG_AsVal_int(obj1, &val2);
19997 if (!SWIG_IsOK(ecode2)) {
19998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19999 }
20000 arg2 = static_cast< int >(val2);
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20004 wxPyEndAllowThreads(__tstate);
20005 if (PyErr_Occurred()) SWIG_fail;
20006 }
20007 {
20008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20009 }
20010 return resultobj;
20011 fail:
20012 return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20017 PyObject *resultobj = 0;
20018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20019 int result;
20020 void *argp1 = 0 ;
20021 int res1 = 0 ;
20022 PyObject *swig_obj[1] ;
20023
20024 if (!args) SWIG_fail;
20025 swig_obj[0] = args;
20026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20027 if (!SWIG_IsOK(res1)) {
20028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20029 }
20030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20031 {
20032 PyThreadState* __tstate = wxPyBeginAllowThreads();
20033 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20034 wxPyEndAllowThreads(__tstate);
20035 if (PyErr_Occurred()) SWIG_fail;
20036 }
20037 resultobj = SWIG_From_int(static_cast< int >(result));
20038 return resultobj;
20039 fail:
20040 return NULL;
20041 }
20042
20043
20044 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20045 PyObject *resultobj = 0;
20046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20047 bool result;
20048 void *argp1 = 0 ;
20049 int res1 = 0 ;
20050 PyObject *swig_obj[1] ;
20051
20052 if (!args) SWIG_fail;
20053 swig_obj[0] = args;
20054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20057 }
20058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 {
20066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20067 }
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20075 PyObject *resultobj = 0;
20076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20077 bool result;
20078 void *argp1 = 0 ;
20079 int res1 = 0 ;
20080 PyObject *swig_obj[1] ;
20081
20082 if (!args) SWIG_fail;
20083 swig_obj[0] = args;
20084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20085 if (!SWIG_IsOK(res1)) {
20086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20087 }
20088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 {
20096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20097 }
20098 return resultobj;
20099 fail:
20100 return NULL;
20101 }
20102
20103
20104 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20105 PyObject *resultobj = 0;
20106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20107 bool result;
20108 void *argp1 = 0 ;
20109 int res1 = 0 ;
20110 PyObject *swig_obj[1] ;
20111
20112 if (!args) SWIG_fail;
20113 swig_obj[0] = args;
20114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20115 if (!SWIG_IsOK(res1)) {
20116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20117 }
20118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20122 wxPyEndAllowThreads(__tstate);
20123 if (PyErr_Occurred()) SWIG_fail;
20124 }
20125 {
20126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20127 }
20128 return resultobj;
20129 fail:
20130 return NULL;
20131 }
20132
20133
20134 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20135 PyObject *resultobj = 0;
20136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20137 bool result;
20138 void *argp1 = 0 ;
20139 int res1 = 0 ;
20140 PyObject *swig_obj[1] ;
20141
20142 if (!args) SWIG_fail;
20143 swig_obj[0] = args;
20144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20145 if (!SWIG_IsOK(res1)) {
20146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20147 }
20148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20149 {
20150 PyThreadState* __tstate = wxPyBeginAllowThreads();
20151 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 {
20156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20157 }
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20165 PyObject *resultobj = 0;
20166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20167 bool result;
20168 void *argp1 = 0 ;
20169 int res1 = 0 ;
20170 PyObject *swig_obj[1] ;
20171
20172 if (!args) SWIG_fail;
20173 swig_obj[0] = args;
20174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20175 if (!SWIG_IsOK(res1)) {
20176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20177 }
20178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20179 {
20180 PyThreadState* __tstate = wxPyBeginAllowThreads();
20181 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 {
20186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20187 }
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20195 PyObject *resultobj = 0;
20196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20197 bool result;
20198 void *argp1 = 0 ;
20199 int res1 = 0 ;
20200 PyObject *swig_obj[1] ;
20201
20202 if (!args) SWIG_fail;
20203 swig_obj[0] = args;
20204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20205 if (!SWIG_IsOK(res1)) {
20206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20207 }
20208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20212 wxPyEndAllowThreads(__tstate);
20213 if (PyErr_Occurred()) SWIG_fail;
20214 }
20215 {
20216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20217 }
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20225 PyObject *resultobj = 0;
20226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20227 bool result;
20228 void *argp1 = 0 ;
20229 int res1 = 0 ;
20230 PyObject *swig_obj[1] ;
20231
20232 if (!args) SWIG_fail;
20233 swig_obj[0] = args;
20234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20235 if (!SWIG_IsOK(res1)) {
20236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20237 }
20238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20239 {
20240 PyThreadState* __tstate = wxPyBeginAllowThreads();
20241 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 {
20246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20247 }
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 PyObject *resultobj = 0;
20256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20257 bool result;
20258 void *argp1 = 0 ;
20259 int res1 = 0 ;
20260 PyObject *swig_obj[1] ;
20261
20262 if (!args) SWIG_fail;
20263 swig_obj[0] = args;
20264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20265 if (!SWIG_IsOK(res1)) {
20266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20267 }
20268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20269 {
20270 PyThreadState* __tstate = wxPyBeginAllowThreads();
20271 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 {
20276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20277 }
20278 return resultobj;
20279 fail:
20280 return NULL;
20281 }
20282
20283
20284 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20285 PyObject *resultobj = 0;
20286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20287 bool result;
20288 void *argp1 = 0 ;
20289 int res1 = 0 ;
20290 PyObject *swig_obj[1] ;
20291
20292 if (!args) SWIG_fail;
20293 swig_obj[0] = args;
20294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20295 if (!SWIG_IsOK(res1)) {
20296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20297 }
20298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 {
20306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20307 }
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20315 PyObject *resultobj = 0;
20316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20317 bool result;
20318 void *argp1 = 0 ;
20319 int res1 = 0 ;
20320 PyObject *swig_obj[1] ;
20321
20322 if (!args) SWIG_fail;
20323 swig_obj[0] = args;
20324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20325 if (!SWIG_IsOK(res1)) {
20326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20327 }
20328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 {
20336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20337 }
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20347 bool result;
20348 void *argp1 = 0 ;
20349 int res1 = 0 ;
20350 PyObject *swig_obj[1] ;
20351
20352 if (!args) SWIG_fail;
20353 swig_obj[0] = args;
20354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20355 if (!SWIG_IsOK(res1)) {
20356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20357 }
20358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 {
20366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20367 }
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20377 bool result;
20378 void *argp1 = 0 ;
20379 int res1 = 0 ;
20380 PyObject *swig_obj[1] ;
20381
20382 if (!args) SWIG_fail;
20383 swig_obj[0] = args;
20384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20385 if (!SWIG_IsOK(res1)) {
20386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20387 }
20388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20389 {
20390 PyThreadState* __tstate = wxPyBeginAllowThreads();
20391 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 {
20396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20397 }
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20405 PyObject *resultobj = 0;
20406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20407 bool result;
20408 void *argp1 = 0 ;
20409 int res1 = 0 ;
20410 PyObject *swig_obj[1] ;
20411
20412 if (!args) SWIG_fail;
20413 swig_obj[0] = args;
20414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20415 if (!SWIG_IsOK(res1)) {
20416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20417 }
20418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 {
20426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *resultobj = 0;
20436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20437 bool result;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 PyObject *swig_obj[1] ;
20441
20442 if (!args) SWIG_fail;
20443 swig_obj[0] = args;
20444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20447 }
20448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 {
20456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20457 }
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 PyObject *swig_obj[1] ;
20471
20472 if (!args) SWIG_fail;
20473 swig_obj[0] = args;
20474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20477 }
20478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (bool)(arg1)->LeftIsDown();
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20487 }
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495 PyObject *resultobj = 0;
20496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20497 bool result;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject *swig_obj[1] ;
20501
20502 if (!args) SWIG_fail;
20503 swig_obj[0] = args;
20504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20505 if (!SWIG_IsOK(res1)) {
20506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20507 }
20508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (bool)(arg1)->MiddleIsDown();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 {
20516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20517 }
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20527 bool result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20537 }
20538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (bool)(arg1)->RightIsDown();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20555 PyObject *resultobj = 0;
20556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20557 bool result;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 PyObject *swig_obj[1] ;
20561
20562 if (!args) SWIG_fail;
20563 swig_obj[0] = args;
20564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20567 }
20568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20577 }
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20585 PyObject *resultobj = 0;
20586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20587 bool result;
20588 void *argp1 = 0 ;
20589 int res1 = 0 ;
20590 PyObject *swig_obj[1] ;
20591
20592 if (!args) SWIG_fail;
20593 swig_obj[0] = args;
20594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20595 if (!SWIG_IsOK(res1)) {
20596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20597 }
20598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 {
20606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20607 }
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20615 PyObject *resultobj = 0;
20616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20617 bool result;
20618 void *argp1 = 0 ;
20619 int res1 = 0 ;
20620 PyObject *swig_obj[1] ;
20621
20622 if (!args) SWIG_fail;
20623 swig_obj[0] = args;
20624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20627 }
20628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *resultobj = 0;
20646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20647 bool result;
20648 void *argp1 = 0 ;
20649 int res1 = 0 ;
20650 PyObject *swig_obj[1] ;
20651
20652 if (!args) SWIG_fail;
20653 swig_obj[0] = args;
20654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20655 if (!SWIG_IsOK(res1)) {
20656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20657 }
20658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 wxPoint result;
20678 void *argp1 = 0 ;
20679 int res1 = 0 ;
20680 PyObject *swig_obj[1] ;
20681
20682 if (!args) SWIG_fail;
20683 swig_obj[0] = args;
20684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20687 }
20688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (arg1)->GetPosition();
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20703 PyObject *resultobj = 0;
20704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20705 long *arg2 = (long *) 0 ;
20706 long *arg3 = (long *) 0 ;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 long temp2 ;
20710 int res2 = SWIG_TMPOBJ ;
20711 long temp3 ;
20712 int res3 = SWIG_TMPOBJ ;
20713 PyObject *swig_obj[1] ;
20714
20715 arg2 = &temp2;
20716 arg3 = &temp3;
20717 if (!args) SWIG_fail;
20718 swig_obj[0] = args;
20719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20722 }
20723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20724 {
20725 PyThreadState* __tstate = wxPyBeginAllowThreads();
20726 (arg1)->GetPosition(arg2,arg3);
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 resultobj = SWIG_Py_Void();
20731 if (SWIG_IsTmpObj(res2)) {
20732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20733 } else {
20734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20736 }
20737 if (SWIG_IsTmpObj(res3)) {
20738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20739 } else {
20740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20742 }
20743 return resultobj;
20744 fail:
20745 return NULL;
20746 }
20747
20748
20749 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20750 PyObject *resultobj = 0;
20751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20752 wxDC *arg2 = 0 ;
20753 wxPoint result;
20754 void *argp1 = 0 ;
20755 int res1 = 0 ;
20756 void *argp2 = 0 ;
20757 int res2 = 0 ;
20758 PyObject * obj0 = 0 ;
20759 PyObject * obj1 = 0 ;
20760 char * kwnames[] = {
20761 (char *) "self",(char *) "dc", NULL
20762 };
20763
20764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20768 }
20769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20771 if (!SWIG_IsOK(res2)) {
20772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20773 }
20774 if (!argp2) {
20775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20776 }
20777 arg2 = reinterpret_cast< wxDC * >(argp2);
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20781 wxPyEndAllowThreads(__tstate);
20782 if (PyErr_Occurred()) SWIG_fail;
20783 }
20784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20785 return resultobj;
20786 fail:
20787 return NULL;
20788 }
20789
20790
20791 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 PyObject *resultobj = 0;
20793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20794 int result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 PyObject *swig_obj[1] ;
20798
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (int)((wxMouseEvent const *)arg1)->GetX();
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 resultobj = SWIG_From_int(static_cast< int >(result));
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20820 PyObject *resultobj = 0;
20821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20822 int result;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 PyObject *swig_obj[1] ;
20826
20827 if (!args) SWIG_fail;
20828 swig_obj[0] = args;
20829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20830 if (!SWIG_IsOK(res1)) {
20831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20832 }
20833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20834 {
20835 PyThreadState* __tstate = wxPyBeginAllowThreads();
20836 result = (int)((wxMouseEvent const *)arg1)->GetY();
20837 wxPyEndAllowThreads(__tstate);
20838 if (PyErr_Occurred()) SWIG_fail;
20839 }
20840 resultobj = SWIG_From_int(static_cast< int >(result));
20841 return resultobj;
20842 fail:
20843 return NULL;
20844 }
20845
20846
20847 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20848 PyObject *resultobj = 0;
20849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20850 int result;
20851 void *argp1 = 0 ;
20852 int res1 = 0 ;
20853 PyObject *swig_obj[1] ;
20854
20855 if (!args) SWIG_fail;
20856 swig_obj[0] = args;
20857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20858 if (!SWIG_IsOK(res1)) {
20859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20860 }
20861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20865 wxPyEndAllowThreads(__tstate);
20866 if (PyErr_Occurred()) SWIG_fail;
20867 }
20868 resultobj = SWIG_From_int(static_cast< int >(result));
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20876 PyObject *resultobj = 0;
20877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20878 int result;
20879 void *argp1 = 0 ;
20880 int res1 = 0 ;
20881 PyObject *swig_obj[1] ;
20882
20883 if (!args) SWIG_fail;
20884 swig_obj[0] = args;
20885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20888 }
20889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 resultobj = SWIG_From_int(static_cast< int >(result));
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20904 PyObject *resultobj = 0;
20905 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20906 int result;
20907 void *argp1 = 0 ;
20908 int res1 = 0 ;
20909 PyObject *swig_obj[1] ;
20910
20911 if (!args) SWIG_fail;
20912 swig_obj[0] = args;
20913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20914 if (!SWIG_IsOK(res1)) {
20915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20916 }
20917 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20918 {
20919 PyThreadState* __tstate = wxPyBeginAllowThreads();
20920 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 resultobj = SWIG_From_int(static_cast< int >(result));
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20932 PyObject *resultobj = 0;
20933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20934 bool result;
20935 void *argp1 = 0 ;
20936 int res1 = 0 ;
20937 PyObject *swig_obj[1] ;
20938
20939 if (!args) SWIG_fail;
20940 swig_obj[0] = args;
20941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20942 if (!SWIG_IsOK(res1)) {
20943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20944 }
20945 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 {
20953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20954 }
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20964 int arg2 ;
20965 void *argp1 = 0 ;
20966 int res1 = 0 ;
20967 int val2 ;
20968 int ecode2 = 0 ;
20969 PyObject *swig_obj[2] ;
20970
20971 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20975 }
20976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20977 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20978 if (!SWIG_IsOK(ecode2)) {
20979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20980 }
20981 arg2 = static_cast< int >(val2);
20982 if (arg1) (arg1)->m_x = arg2;
20983
20984 resultobj = SWIG_Py_Void();
20985 return resultobj;
20986 fail:
20987 return NULL;
20988 }
20989
20990
20991 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20992 PyObject *resultobj = 0;
20993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20994 int result;
20995 void *argp1 = 0 ;
20996 int res1 = 0 ;
20997 PyObject *swig_obj[1] ;
20998
20999 if (!args) SWIG_fail;
21000 swig_obj[0] = args;
21001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21004 }
21005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21006 result = (int) ((arg1)->m_x);
21007 resultobj = SWIG_From_int(static_cast< int >(result));
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 int arg2 ;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 int val2 ;
21021 int ecode2 = 0 ;
21022 PyObject *swig_obj[2] ;
21023
21024 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21028 }
21029 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21031 if (!SWIG_IsOK(ecode2)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21033 }
21034 arg2 = static_cast< int >(val2);
21035 if (arg1) (arg1)->m_y = arg2;
21036
21037 resultobj = SWIG_Py_Void();
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *resultobj = 0;
21046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21047 int result;
21048 void *argp1 = 0 ;
21049 int res1 = 0 ;
21050 PyObject *swig_obj[1] ;
21051
21052 if (!args) SWIG_fail;
21053 swig_obj[0] = args;
21054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21057 }
21058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21059 result = (int) ((arg1)->m_y);
21060 resultobj = SWIG_From_int(static_cast< int >(result));
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068 PyObject *resultobj = 0;
21069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21070 bool arg2 ;
21071 void *argp1 = 0 ;
21072 int res1 = 0 ;
21073 bool val2 ;
21074 int ecode2 = 0 ;
21075 PyObject *swig_obj[2] ;
21076
21077 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21079 if (!SWIG_IsOK(res1)) {
21080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21081 }
21082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21083 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21084 if (!SWIG_IsOK(ecode2)) {
21085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21086 }
21087 arg2 = static_cast< bool >(val2);
21088 if (arg1) (arg1)->m_leftDown = arg2;
21089
21090 resultobj = SWIG_Py_Void();
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21100 bool result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 PyObject *swig_obj[1] ;
21104
21105 if (!args) SWIG_fail;
21106 swig_obj[0] = args;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21110 }
21111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21112 result = (bool) ((arg1)->m_leftDown);
21113 {
21114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 bool arg2 ;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 bool val2 ;
21129 int ecode2 = 0 ;
21130 PyObject *swig_obj[2] ;
21131
21132 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21134 if (!SWIG_IsOK(res1)) {
21135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21136 }
21137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21138 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21139 if (!SWIG_IsOK(ecode2)) {
21140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21141 }
21142 arg2 = static_cast< bool >(val2);
21143 if (arg1) (arg1)->m_middleDown = arg2;
21144
21145 resultobj = SWIG_Py_Void();
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21165 }
21166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21167 result = (bool) ((arg1)->m_middleDown);
21168 {
21169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21170 }
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21178 PyObject *resultobj = 0;
21179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21180 bool arg2 ;
21181 void *argp1 = 0 ;
21182 int res1 = 0 ;
21183 bool val2 ;
21184 int ecode2 = 0 ;
21185 PyObject *swig_obj[2] ;
21186
21187 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21191 }
21192 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21193 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21194 if (!SWIG_IsOK(ecode2)) {
21195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21196 }
21197 arg2 = static_cast< bool >(val2);
21198 if (arg1) (arg1)->m_rightDown = arg2;
21199
21200 resultobj = SWIG_Py_Void();
21201 return resultobj;
21202 fail:
21203 return NULL;
21204 }
21205
21206
21207 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21208 PyObject *resultobj = 0;
21209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21210 bool result;
21211 void *argp1 = 0 ;
21212 int res1 = 0 ;
21213 PyObject *swig_obj[1] ;
21214
21215 if (!args) SWIG_fail;
21216 swig_obj[0] = args;
21217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21218 if (!SWIG_IsOK(res1)) {
21219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21220 }
21221 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21222 result = (bool) ((arg1)->m_rightDown);
21223 {
21224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21225 }
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21233 PyObject *resultobj = 0;
21234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21235 bool arg2 ;
21236 void *argp1 = 0 ;
21237 int res1 = 0 ;
21238 bool val2 ;
21239 int ecode2 = 0 ;
21240 PyObject *swig_obj[2] ;
21241
21242 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21244 if (!SWIG_IsOK(res1)) {
21245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21246 }
21247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21248 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21249 if (!SWIG_IsOK(ecode2)) {
21250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21251 }
21252 arg2 = static_cast< bool >(val2);
21253 if (arg1) (arg1)->m_controlDown = arg2;
21254
21255 resultobj = SWIG_Py_Void();
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21263 PyObject *resultobj = 0;
21264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21265 bool result;
21266 void *argp1 = 0 ;
21267 int res1 = 0 ;
21268 PyObject *swig_obj[1] ;
21269
21270 if (!args) SWIG_fail;
21271 swig_obj[0] = args;
21272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21273 if (!SWIG_IsOK(res1)) {
21274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21275 }
21276 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21277 result = (bool) ((arg1)->m_controlDown);
21278 {
21279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21288 PyObject *resultobj = 0;
21289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21290 bool arg2 ;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 bool val2 ;
21294 int ecode2 = 0 ;
21295 PyObject *swig_obj[2] ;
21296
21297 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21299 if (!SWIG_IsOK(res1)) {
21300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21301 }
21302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21303 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21304 if (!SWIG_IsOK(ecode2)) {
21305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21306 }
21307 arg2 = static_cast< bool >(val2);
21308 if (arg1) (arg1)->m_shiftDown = arg2;
21309
21310 resultobj = SWIG_Py_Void();
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21318 PyObject *resultobj = 0;
21319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21320 bool result;
21321 void *argp1 = 0 ;
21322 int res1 = 0 ;
21323 PyObject *swig_obj[1] ;
21324
21325 if (!args) SWIG_fail;
21326 swig_obj[0] = args;
21327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21328 if (!SWIG_IsOK(res1)) {
21329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21330 }
21331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21332 result = (bool) ((arg1)->m_shiftDown);
21333 {
21334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21335 }
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21343 PyObject *resultobj = 0;
21344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21345 bool arg2 ;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool val2 ;
21349 int ecode2 = 0 ;
21350 PyObject *swig_obj[2] ;
21351
21352 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21358 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21361 }
21362 arg2 = static_cast< bool >(val2);
21363 if (arg1) (arg1)->m_altDown = arg2;
21364
21365 resultobj = SWIG_Py_Void();
21366 return resultobj;
21367 fail:
21368 return NULL;
21369 }
21370
21371
21372 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21373 PyObject *resultobj = 0;
21374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21375 bool result;
21376 void *argp1 = 0 ;
21377 int res1 = 0 ;
21378 PyObject *swig_obj[1] ;
21379
21380 if (!args) SWIG_fail;
21381 swig_obj[0] = args;
21382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21383 if (!SWIG_IsOK(res1)) {
21384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21385 }
21386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21387 result = (bool) ((arg1)->m_altDown);
21388 {
21389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21398 PyObject *resultobj = 0;
21399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21400 bool arg2 ;
21401 void *argp1 = 0 ;
21402 int res1 = 0 ;
21403 bool val2 ;
21404 int ecode2 = 0 ;
21405 PyObject *swig_obj[2] ;
21406
21407 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21411 }
21412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21413 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21414 if (!SWIG_IsOK(ecode2)) {
21415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21416 }
21417 arg2 = static_cast< bool >(val2);
21418 if (arg1) (arg1)->m_metaDown = arg2;
21419
21420 resultobj = SWIG_Py_Void();
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21428 PyObject *resultobj = 0;
21429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21430 bool result;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 PyObject *swig_obj[1] ;
21434
21435 if (!args) SWIG_fail;
21436 swig_obj[0] = args;
21437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21438 if (!SWIG_IsOK(res1)) {
21439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21440 }
21441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21442 result = (bool) ((arg1)->m_metaDown);
21443 {
21444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21445 }
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21455 int arg2 ;
21456 void *argp1 = 0 ;
21457 int res1 = 0 ;
21458 int val2 ;
21459 int ecode2 = 0 ;
21460 PyObject *swig_obj[2] ;
21461
21462 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21464 if (!SWIG_IsOK(res1)) {
21465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21466 }
21467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21468 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21469 if (!SWIG_IsOK(ecode2)) {
21470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21471 }
21472 arg2 = static_cast< int >(val2);
21473 if (arg1) (arg1)->m_wheelRotation = arg2;
21474
21475 resultobj = SWIG_Py_Void();
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21483 PyObject *resultobj = 0;
21484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21485 int result;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 PyObject *swig_obj[1] ;
21489
21490 if (!args) SWIG_fail;
21491 swig_obj[0] = args;
21492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 result = (int) ((arg1)->m_wheelRotation);
21498 resultobj = SWIG_From_int(static_cast< int >(result));
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21508 int arg2 ;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 int val2 ;
21512 int ecode2 = 0 ;
21513 PyObject *swig_obj[2] ;
21514
21515 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21521 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21522 if (!SWIG_IsOK(ecode2)) {
21523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21524 }
21525 arg2 = static_cast< int >(val2);
21526 if (arg1) (arg1)->m_wheelDelta = arg2;
21527
21528 resultobj = SWIG_Py_Void();
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21536 PyObject *resultobj = 0;
21537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21538 int result;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 PyObject *swig_obj[1] ;
21542
21543 if (!args) SWIG_fail;
21544 swig_obj[0] = args;
21545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21546 if (!SWIG_IsOK(res1)) {
21547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21548 }
21549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21550 result = (int) ((arg1)->m_wheelDelta);
21551 resultobj = SWIG_From_int(static_cast< int >(result));
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 int arg2 ;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 int val2 ;
21565 int ecode2 = 0 ;
21566 PyObject *swig_obj[2] ;
21567
21568 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21572 }
21573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21574 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21575 if (!SWIG_IsOK(ecode2)) {
21576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21577 }
21578 arg2 = static_cast< int >(val2);
21579 if (arg1) (arg1)->m_linesPerAction = arg2;
21580
21581 resultobj = SWIG_Py_Void();
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 int result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 result = (int) ((arg1)->m_linesPerAction);
21604 resultobj = SWIG_From_int(static_cast< int >(result));
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *obj;
21613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21614 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21615 return SWIG_Py_Void();
21616 }
21617
21618 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 return SWIG_Python_InitShadowInstance(args);
21620 }
21621
21622 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj = 0;
21624 int arg1 = (int) 0 ;
21625 int arg2 = (int) 0 ;
21626 wxSetCursorEvent *result = 0 ;
21627 int val1 ;
21628 int ecode1 = 0 ;
21629 int val2 ;
21630 int ecode2 = 0 ;
21631 PyObject * obj0 = 0 ;
21632 PyObject * obj1 = 0 ;
21633 char * kwnames[] = {
21634 (char *) "x",(char *) "y", NULL
21635 };
21636
21637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21638 if (obj0) {
21639 ecode1 = SWIG_AsVal_int(obj0, &val1);
21640 if (!SWIG_IsOK(ecode1)) {
21641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21642 }
21643 arg1 = static_cast< int >(val1);
21644 }
21645 if (obj1) {
21646 ecode2 = SWIG_AsVal_int(obj1, &val2);
21647 if (!SWIG_IsOK(ecode2)) {
21648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21649 }
21650 arg2 = static_cast< int >(val2);
21651 }
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21668 int result;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21678 }
21679 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 resultobj = SWIG_From_int(static_cast< int >(result));
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21694 PyObject *resultobj = 0;
21695 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21696 int result;
21697 void *argp1 = 0 ;
21698 int res1 = 0 ;
21699 PyObject *swig_obj[1] ;
21700
21701 if (!args) SWIG_fail;
21702 swig_obj[0] = args;
21703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21704 if (!SWIG_IsOK(res1)) {
21705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21706 }
21707 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21711 wxPyEndAllowThreads(__tstate);
21712 if (PyErr_Occurred()) SWIG_fail;
21713 }
21714 resultobj = SWIG_From_int(static_cast< int >(result));
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21722 PyObject *resultobj = 0;
21723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21724 wxCursor *arg2 = 0 ;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 void *argp2 = 0 ;
21728 int res2 = 0 ;
21729 PyObject * obj0 = 0 ;
21730 PyObject * obj1 = 0 ;
21731 char * kwnames[] = {
21732 (char *) "self",(char *) "cursor", NULL
21733 };
21734
21735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21737 if (!SWIG_IsOK(res1)) {
21738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21739 }
21740 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21742 if (!SWIG_IsOK(res2)) {
21743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21744 }
21745 if (!argp2) {
21746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21747 }
21748 arg2 = reinterpret_cast< wxCursor * >(argp2);
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 (arg1)->SetCursor((wxCursor const &)*arg2);
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 resultobj = SWIG_Py_Void();
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21763 PyObject *resultobj = 0;
21764 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21765 wxCursor *result = 0 ;
21766 void *argp1 = 0 ;
21767 int res1 = 0 ;
21768 PyObject *swig_obj[1] ;
21769
21770 if (!args) SWIG_fail;
21771 swig_obj[0] = args;
21772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21773 if (!SWIG_IsOK(res1)) {
21774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21775 }
21776 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21777 {
21778 PyThreadState* __tstate = wxPyBeginAllowThreads();
21779 {
21780 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21781 result = (wxCursor *) &_result_ref;
21782 }
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 {
21787 wxCursor* resultptr = new wxCursor(*result);
21788 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21789 }
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21799 bool result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21809 }
21810 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 {
21818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21819 }
21820 return resultobj;
21821 fail:
21822 return NULL;
21823 }
21824
21825
21826 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21827 PyObject *obj;
21828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21829 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21830 return SWIG_Py_Void();
21831 }
21832
21833 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21834 return SWIG_Python_InitShadowInstance(args);
21835 }
21836
21837 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj = 0;
21839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21840 wxKeyEvent *result = 0 ;
21841 int val1 ;
21842 int ecode1 = 0 ;
21843 PyObject * obj0 = 0 ;
21844 char * kwnames[] = {
21845 (char *) "eventType", NULL
21846 };
21847
21848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21849 if (obj0) {
21850 ecode1 = SWIG_AsVal_int(obj0, &val1);
21851 if (!SWIG_IsOK(ecode1)) {
21852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21853 }
21854 arg1 = static_cast< wxEventType >(val1);
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21863 return resultobj;
21864 fail:
21865 return NULL;
21866 }
21867
21868
21869 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21870 PyObject *resultobj = 0;
21871 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21872 int result;
21873 void *argp1 = 0 ;
21874 int res1 = 0 ;
21875 PyObject *swig_obj[1] ;
21876
21877 if (!args) SWIG_fail;
21878 swig_obj[0] = args;
21879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21880 if (!SWIG_IsOK(res1)) {
21881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21882 }
21883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 resultobj = SWIG_From_int(static_cast< int >(result));
21891 return resultobj;
21892 fail:
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21898 PyObject *resultobj = 0;
21899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21900 bool result;
21901 void *argp1 = 0 ;
21902 int res1 = 0 ;
21903 PyObject *swig_obj[1] ;
21904
21905 if (!args) SWIG_fail;
21906 swig_obj[0] = args;
21907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21910 }
21911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21930 bool result;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 PyObject *swig_obj[1] ;
21934
21935 if (!args) SWIG_fail;
21936 swig_obj[0] = args;
21937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21940 }
21941 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 {
21949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *resultobj = 0;
21959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21960 bool result;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 PyObject *swig_obj[1] ;
21964
21965 if (!args) SWIG_fail;
21966 swig_obj[0] = args;
21967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21970 }
21971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21988 PyObject *resultobj = 0;
21989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21990 bool result;
21991 void *argp1 = 0 ;
21992 int res1 = 0 ;
21993 PyObject *swig_obj[1] ;
21994
21995 if (!args) SWIG_fail;
21996 swig_obj[0] = args;
21997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22000 }
22001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22018 PyObject *resultobj = 0;
22019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22020 bool result;
22021 void *argp1 = 0 ;
22022 int res1 = 0 ;
22023 PyObject *swig_obj[1] ;
22024
22025 if (!args) SWIG_fail;
22026 swig_obj[0] = args;
22027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22030 }
22031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 {
22039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22040 }
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22048 PyObject *resultobj = 0;
22049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22050 bool result;
22051 void *argp1 = 0 ;
22052 int res1 = 0 ;
22053 PyObject *swig_obj[1] ;
22054
22055 if (!args) SWIG_fail;
22056 swig_obj[0] = args;
22057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22058 if (!SWIG_IsOK(res1)) {
22059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22060 }
22061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22070 }
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22078 PyObject *resultobj = 0;
22079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22080 int result;
22081 void *argp1 = 0 ;
22082 int res1 = 0 ;
22083 PyObject *swig_obj[1] ;
22084
22085 if (!args) SWIG_fail;
22086 swig_obj[0] = args;
22087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22088 if (!SWIG_IsOK(res1)) {
22089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22090 }
22091 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 resultobj = SWIG_From_int(static_cast< int >(result));
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22108 int result;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22118 }
22119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 resultobj = SWIG_From_int(static_cast< int >(result));
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22134 PyObject *resultobj = 0;
22135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22136 unsigned int result;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 PyObject *swig_obj[1] ;
22140
22141 if (!args) SWIG_fail;
22142 swig_obj[0] = args;
22143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22146 }
22147 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *resultobj = 0;
22163 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22164 unsigned int result;
22165 void *argp1 = 0 ;
22166 int res1 = 0 ;
22167 PyObject *swig_obj[1] ;
22168
22169 if (!args) SWIG_fail;
22170 swig_obj[0] = args;
22171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22174 }
22175 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *resultobj = 0;
22191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22192 wxPoint result;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject *swig_obj[1] ;
22196
22197 if (!args) SWIG_fail;
22198 swig_obj[0] = args;
22199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22202 }
22203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (arg1)->GetPosition();
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22220 long *arg2 = (long *) 0 ;
22221 long *arg3 = (long *) 0 ;
22222 void *argp1 = 0 ;
22223 int res1 = 0 ;
22224 long temp2 ;
22225 int res2 = SWIG_TMPOBJ ;
22226 long temp3 ;
22227 int res3 = SWIG_TMPOBJ ;
22228 PyObject *swig_obj[1] ;
22229
22230 arg2 = &temp2;
22231 arg3 = &temp3;
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22237 }
22238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 (arg1)->GetPosition(arg2,arg3);
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 resultobj = SWIG_Py_Void();
22246 if (SWIG_IsTmpObj(res2)) {
22247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22248 } else {
22249 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22251 }
22252 if (SWIG_IsTmpObj(res3)) {
22253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22254 } else {
22255 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22257 }
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265 PyObject *resultobj = 0;
22266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22267 int result;
22268 void *argp1 = 0 ;
22269 int res1 = 0 ;
22270 PyObject *swig_obj[1] ;
22271
22272 if (!args) SWIG_fail;
22273 swig_obj[0] = args;
22274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22275 if (!SWIG_IsOK(res1)) {
22276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22277 }
22278 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 result = (int)((wxKeyEvent const *)arg1)->GetX();
22282 wxPyEndAllowThreads(__tstate);
22283 if (PyErr_Occurred()) SWIG_fail;
22284 }
22285 resultobj = SWIG_From_int(static_cast< int >(result));
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22293 PyObject *resultobj = 0;
22294 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22295 int result;
22296 void *argp1 = 0 ;
22297 int res1 = 0 ;
22298 PyObject *swig_obj[1] ;
22299
22300 if (!args) SWIG_fail;
22301 swig_obj[0] = args;
22302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22303 if (!SWIG_IsOK(res1)) {
22304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22305 }
22306 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22307 {
22308 PyThreadState* __tstate = wxPyBeginAllowThreads();
22309 result = (int)((wxKeyEvent const *)arg1)->GetY();
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 resultobj = SWIG_From_int(static_cast< int >(result));
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *resultobj = 0;
22322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22323 int arg2 ;
22324 void *argp1 = 0 ;
22325 int res1 = 0 ;
22326 int val2 ;
22327 int ecode2 = 0 ;
22328 PyObject *swig_obj[2] ;
22329
22330 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22332 if (!SWIG_IsOK(res1)) {
22333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22334 }
22335 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22336 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22337 if (!SWIG_IsOK(ecode2)) {
22338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22339 }
22340 arg2 = static_cast< int >(val2);
22341 if (arg1) (arg1)->m_x = arg2;
22342
22343 resultobj = SWIG_Py_Void();
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 PyObject *resultobj = 0;
22352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22353 int result;
22354 void *argp1 = 0 ;
22355 int res1 = 0 ;
22356 PyObject *swig_obj[1] ;
22357
22358 if (!args) SWIG_fail;
22359 swig_obj[0] = args;
22360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22361 if (!SWIG_IsOK(res1)) {
22362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22363 }
22364 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22365 result = (int) ((arg1)->m_x);
22366 resultobj = SWIG_From_int(static_cast< int >(result));
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22374 PyObject *resultobj = 0;
22375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22376 int arg2 ;
22377 void *argp1 = 0 ;
22378 int res1 = 0 ;
22379 int val2 ;
22380 int ecode2 = 0 ;
22381 PyObject *swig_obj[2] ;
22382
22383 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22390 if (!SWIG_IsOK(ecode2)) {
22391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22392 }
22393 arg2 = static_cast< int >(val2);
22394 if (arg1) (arg1)->m_y = arg2;
22395
22396 resultobj = SWIG_Py_Void();
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22416 }
22417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22418 result = (int) ((arg1)->m_y);
22419 resultobj = SWIG_From_int(static_cast< int >(result));
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22427 PyObject *resultobj = 0;
22428 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22429 long arg2 ;
22430 void *argp1 = 0 ;
22431 int res1 = 0 ;
22432 long val2 ;
22433 int ecode2 = 0 ;
22434 PyObject *swig_obj[2] ;
22435
22436 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22438 if (!SWIG_IsOK(res1)) {
22439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22440 }
22441 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22442 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22443 if (!SWIG_IsOK(ecode2)) {
22444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22445 }
22446 arg2 = static_cast< long >(val2);
22447 if (arg1) (arg1)->m_keyCode = arg2;
22448
22449 resultobj = SWIG_Py_Void();
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22459 long result;
22460 void *argp1 = 0 ;
22461 int res1 = 0 ;
22462 PyObject *swig_obj[1] ;
22463
22464 if (!args) SWIG_fail;
22465 swig_obj[0] = args;
22466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22467 if (!SWIG_IsOK(res1)) {
22468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22469 }
22470 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22471 result = (long) ((arg1)->m_keyCode);
22472 resultobj = SWIG_From_long(static_cast< long >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22482 bool arg2 ;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 bool val2 ;
22486 int ecode2 = 0 ;
22487 PyObject *swig_obj[2] ;
22488
22489 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22491 if (!SWIG_IsOK(res1)) {
22492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22493 }
22494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22495 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22496 if (!SWIG_IsOK(ecode2)) {
22497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22498 }
22499 arg2 = static_cast< bool >(val2);
22500 if (arg1) (arg1)->m_controlDown = arg2;
22501
22502 resultobj = SWIG_Py_Void();
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *resultobj = 0;
22511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22512 bool result;
22513 void *argp1 = 0 ;
22514 int res1 = 0 ;
22515 PyObject *swig_obj[1] ;
22516
22517 if (!args) SWIG_fail;
22518 swig_obj[0] = args;
22519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22520 if (!SWIG_IsOK(res1)) {
22521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22522 }
22523 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22524 result = (bool) ((arg1)->m_controlDown);
22525 {
22526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22527 }
22528 return resultobj;
22529 fail:
22530 return NULL;
22531 }
22532
22533
22534 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22535 PyObject *resultobj = 0;
22536 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22537 bool arg2 ;
22538 void *argp1 = 0 ;
22539 int res1 = 0 ;
22540 bool val2 ;
22541 int ecode2 = 0 ;
22542 PyObject *swig_obj[2] ;
22543
22544 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22546 if (!SWIG_IsOK(res1)) {
22547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22548 }
22549 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22550 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22551 if (!SWIG_IsOK(ecode2)) {
22552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22553 }
22554 arg2 = static_cast< bool >(val2);
22555 if (arg1) (arg1)->m_shiftDown = arg2;
22556
22557 resultobj = SWIG_Py_Void();
22558 return resultobj;
22559 fail:
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565 PyObject *resultobj = 0;
22566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22567 bool result;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 PyObject *swig_obj[1] ;
22571
22572 if (!args) SWIG_fail;
22573 swig_obj[0] = args;
22574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22575 if (!SWIG_IsOK(res1)) {
22576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22577 }
22578 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22579 result = (bool) ((arg1)->m_shiftDown);
22580 {
22581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22582 }
22583 return resultobj;
22584 fail:
22585 return NULL;
22586 }
22587
22588
22589 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22590 PyObject *resultobj = 0;
22591 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22592 bool arg2 ;
22593 void *argp1 = 0 ;
22594 int res1 = 0 ;
22595 bool val2 ;
22596 int ecode2 = 0 ;
22597 PyObject *swig_obj[2] ;
22598
22599 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22601 if (!SWIG_IsOK(res1)) {
22602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22603 }
22604 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22605 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22606 if (!SWIG_IsOK(ecode2)) {
22607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22608 }
22609 arg2 = static_cast< bool >(val2);
22610 if (arg1) (arg1)->m_altDown = arg2;
22611
22612 resultobj = SWIG_Py_Void();
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22620 PyObject *resultobj = 0;
22621 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22622 bool result;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 PyObject *swig_obj[1] ;
22626
22627 if (!args) SWIG_fail;
22628 swig_obj[0] = args;
22629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22630 if (!SWIG_IsOK(res1)) {
22631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22632 }
22633 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22634 result = (bool) ((arg1)->m_altDown);
22635 {
22636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22637 }
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 PyObject *resultobj = 0;
22646 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22647 bool arg2 ;
22648 void *argp1 = 0 ;
22649 int res1 = 0 ;
22650 bool val2 ;
22651 int ecode2 = 0 ;
22652 PyObject *swig_obj[2] ;
22653
22654 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22656 if (!SWIG_IsOK(res1)) {
22657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22658 }
22659 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22660 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22661 if (!SWIG_IsOK(ecode2)) {
22662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22663 }
22664 arg2 = static_cast< bool >(val2);
22665 if (arg1) (arg1)->m_metaDown = arg2;
22666
22667 resultobj = SWIG_Py_Void();
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22675 PyObject *resultobj = 0;
22676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22677 bool result;
22678 void *argp1 = 0 ;
22679 int res1 = 0 ;
22680 PyObject *swig_obj[1] ;
22681
22682 if (!args) SWIG_fail;
22683 swig_obj[0] = args;
22684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22687 }
22688 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22689 result = (bool) ((arg1)->m_metaDown);
22690 {
22691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22692 }
22693 return resultobj;
22694 fail:
22695 return NULL;
22696 }
22697
22698
22699 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22700 PyObject *resultobj = 0;
22701 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22702 bool arg2 ;
22703 void *argp1 = 0 ;
22704 int res1 = 0 ;
22705 bool val2 ;
22706 int ecode2 = 0 ;
22707 PyObject *swig_obj[2] ;
22708
22709 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22711 if (!SWIG_IsOK(res1)) {
22712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22713 }
22714 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22715 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22716 if (!SWIG_IsOK(ecode2)) {
22717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22718 }
22719 arg2 = static_cast< bool >(val2);
22720 if (arg1) (arg1)->m_scanCode = arg2;
22721
22722 resultobj = SWIG_Py_Void();
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22730 PyObject *resultobj = 0;
22731 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22732 bool result;
22733 void *argp1 = 0 ;
22734 int res1 = 0 ;
22735 PyObject *swig_obj[1] ;
22736
22737 if (!args) SWIG_fail;
22738 swig_obj[0] = args;
22739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22740 if (!SWIG_IsOK(res1)) {
22741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22742 }
22743 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22744 result = (bool) ((arg1)->m_scanCode);
22745 {
22746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22747 }
22748 return resultobj;
22749 fail:
22750 return NULL;
22751 }
22752
22753
22754 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22755 PyObject *resultobj = 0;
22756 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22757 unsigned int arg2 ;
22758 void *argp1 = 0 ;
22759 int res1 = 0 ;
22760 unsigned int val2 ;
22761 int ecode2 = 0 ;
22762 PyObject *swig_obj[2] ;
22763
22764 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22766 if (!SWIG_IsOK(res1)) {
22767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22768 }
22769 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22770 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22771 if (!SWIG_IsOK(ecode2)) {
22772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22773 }
22774 arg2 = static_cast< unsigned int >(val2);
22775 if (arg1) (arg1)->m_rawCode = arg2;
22776
22777 resultobj = SWIG_Py_Void();
22778 return resultobj;
22779 fail:
22780 return NULL;
22781 }
22782
22783
22784 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22785 PyObject *resultobj = 0;
22786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22787 unsigned int result;
22788 void *argp1 = 0 ;
22789 int res1 = 0 ;
22790 PyObject *swig_obj[1] ;
22791
22792 if (!args) SWIG_fail;
22793 swig_obj[0] = args;
22794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22795 if (!SWIG_IsOK(res1)) {
22796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22797 }
22798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22799 result = (unsigned int) ((arg1)->m_rawCode);
22800 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22808 PyObject *resultobj = 0;
22809 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22810 unsigned int arg2 ;
22811 void *argp1 = 0 ;
22812 int res1 = 0 ;
22813 unsigned int val2 ;
22814 int ecode2 = 0 ;
22815 PyObject *swig_obj[2] ;
22816
22817 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22819 if (!SWIG_IsOK(res1)) {
22820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22821 }
22822 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22823 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22824 if (!SWIG_IsOK(ecode2)) {
22825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22826 }
22827 arg2 = static_cast< unsigned int >(val2);
22828 if (arg1) (arg1)->m_rawFlags = arg2;
22829
22830 resultobj = SWIG_Py_Void();
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22838 PyObject *resultobj = 0;
22839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22840 unsigned int result;
22841 void *argp1 = 0 ;
22842 int res1 = 0 ;
22843 PyObject *swig_obj[1] ;
22844
22845 if (!args) SWIG_fail;
22846 swig_obj[0] = args;
22847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22848 if (!SWIG_IsOK(res1)) {
22849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22850 }
22851 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22852 result = (unsigned int) ((arg1)->m_rawFlags);
22853 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22854 return resultobj;
22855 fail:
22856 return NULL;
22857 }
22858
22859
22860 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22861 PyObject *obj;
22862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22863 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22864 return SWIG_Py_Void();
22865 }
22866
22867 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 return SWIG_Python_InitShadowInstance(args);
22869 }
22870
22871 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj = 0;
22873 wxSize const &arg1_defvalue = wxDefaultSize ;
22874 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22875 int arg2 = (int) 0 ;
22876 wxSizeEvent *result = 0 ;
22877 wxSize temp1 ;
22878 int val2 ;
22879 int ecode2 = 0 ;
22880 PyObject * obj0 = 0 ;
22881 PyObject * obj1 = 0 ;
22882 char * kwnames[] = {
22883 (char *) "sz",(char *) "winid", NULL
22884 };
22885
22886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22887 if (obj0) {
22888 {
22889 arg1 = &temp1;
22890 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22891 }
22892 }
22893 if (obj1) {
22894 ecode2 = SWIG_AsVal_int(obj1, &val2);
22895 if (!SWIG_IsOK(ecode2)) {
22896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22897 }
22898 arg2 = static_cast< int >(val2);
22899 }
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22907 return resultobj;
22908 fail:
22909 return NULL;
22910 }
22911
22912
22913 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22914 PyObject *resultobj = 0;
22915 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22916 wxSize result;
22917 void *argp1 = 0 ;
22918 int res1 = 0 ;
22919 PyObject *swig_obj[1] ;
22920
22921 if (!args) SWIG_fail;
22922 swig_obj[0] = args;
22923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22926 }
22927 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = ((wxSizeEvent const *)arg1)->GetSize();
22931 wxPyEndAllowThreads(__tstate);
22932 if (PyErr_Occurred()) SWIG_fail;
22933 }
22934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22942 PyObject *resultobj = 0;
22943 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22944 wxRect result;
22945 void *argp1 = 0 ;
22946 int res1 = 0 ;
22947 PyObject *swig_obj[1] ;
22948
22949 if (!args) SWIG_fail;
22950 swig_obj[0] = args;
22951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22952 if (!SWIG_IsOK(res1)) {
22953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22954 }
22955 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 result = ((wxSizeEvent const *)arg1)->GetRect();
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj = 0;
22971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22972 wxRect arg2 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 void *argp2 ;
22976 int res2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "rect", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22987 }
22988 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22989 {
22990 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22991 if (!SWIG_IsOK(res2)) {
22992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22993 }
22994 if (!argp2) {
22995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22996 } else {
22997 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22998 arg2 = *temp;
22999 if (SWIG_IsNewObj(res2)) delete temp;
23000 }
23001 }
23002 {
23003 PyThreadState* __tstate = wxPyBeginAllowThreads();
23004 (arg1)->SetRect(arg2);
23005 wxPyEndAllowThreads(__tstate);
23006 if (PyErr_Occurred()) SWIG_fail;
23007 }
23008 resultobj = SWIG_Py_Void();
23009 return resultobj;
23010 fail:
23011 return NULL;
23012 }
23013
23014
23015 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23016 PyObject *resultobj = 0;
23017 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23018 wxSize arg2 ;
23019 void *argp1 = 0 ;
23020 int res1 = 0 ;
23021 void *argp2 ;
23022 int res2 = 0 ;
23023 PyObject * obj0 = 0 ;
23024 PyObject * obj1 = 0 ;
23025 char * kwnames[] = {
23026 (char *) "self",(char *) "size", NULL
23027 };
23028
23029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23031 if (!SWIG_IsOK(res1)) {
23032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23033 }
23034 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23035 {
23036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23037 if (!SWIG_IsOK(res2)) {
23038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23039 }
23040 if (!argp2) {
23041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23042 } else {
23043 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23044 arg2 = *temp;
23045 if (SWIG_IsNewObj(res2)) delete temp;
23046 }
23047 }
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 wxSizeEvent_SetSize(arg1,arg2);
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_Py_Void();
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23064 wxSize *arg2 = (wxSize *) 0 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 void *argp2 = 0 ;
23068 int res2 = 0 ;
23069 PyObject *swig_obj[2] ;
23070
23071 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23075 }
23076 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23077 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23078 if (!SWIG_IsOK(res2)) {
23079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23080 }
23081 arg2 = reinterpret_cast< wxSize * >(argp2);
23082 if (arg1) (arg1)->m_size = *arg2;
23083
23084 resultobj = SWIG_Py_Void();
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23092 PyObject *resultobj = 0;
23093 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23094 wxSize *result = 0 ;
23095 void *argp1 = 0 ;
23096 int res1 = 0 ;
23097 PyObject *swig_obj[1] ;
23098
23099 if (!args) SWIG_fail;
23100 swig_obj[0] = args;
23101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23102 if (!SWIG_IsOK(res1)) {
23103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23104 }
23105 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23106 result = (wxSize *)& ((arg1)->m_size);
23107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115 PyObject *resultobj = 0;
23116 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23117 wxRect *arg2 = (wxRect *) 0 ;
23118 void *argp1 = 0 ;
23119 int res1 = 0 ;
23120 void *argp2 = 0 ;
23121 int res2 = 0 ;
23122 PyObject *swig_obj[2] ;
23123
23124 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23126 if (!SWIG_IsOK(res1)) {
23127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23128 }
23129 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23130 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23131 if (!SWIG_IsOK(res2)) {
23132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23133 }
23134 arg2 = reinterpret_cast< wxRect * >(argp2);
23135 if (arg1) (arg1)->m_rect = *arg2;
23136
23137 resultobj = SWIG_Py_Void();
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23145 PyObject *resultobj = 0;
23146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23147 wxRect *result = 0 ;
23148 void *argp1 = 0 ;
23149 int res1 = 0 ;
23150 PyObject *swig_obj[1] ;
23151
23152 if (!args) SWIG_fail;
23153 swig_obj[0] = args;
23154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23155 if (!SWIG_IsOK(res1)) {
23156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23157 }
23158 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23159 result = (wxRect *)& ((arg1)->m_rect);
23160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *obj;
23169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23170 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23171 return SWIG_Py_Void();
23172 }
23173
23174 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23175 return SWIG_Python_InitShadowInstance(args);
23176 }
23177
23178 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj = 0;
23180 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23181 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23182 int arg2 = (int) 0 ;
23183 wxMoveEvent *result = 0 ;
23184 wxPoint temp1 ;
23185 int val2 ;
23186 int ecode2 = 0 ;
23187 PyObject * obj0 = 0 ;
23188 PyObject * obj1 = 0 ;
23189 char * kwnames[] = {
23190 (char *) "pos",(char *) "winid", NULL
23191 };
23192
23193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23194 if (obj0) {
23195 {
23196 arg1 = &temp1;
23197 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23198 }
23199 }
23200 if (obj1) {
23201 ecode2 = SWIG_AsVal_int(obj1, &val2);
23202 if (!SWIG_IsOK(ecode2)) {
23203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23204 }
23205 arg2 = static_cast< int >(val2);
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23221 PyObject *resultobj = 0;
23222 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23223 wxPoint result;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 PyObject *swig_obj[1] ;
23227
23228 if (!args) SWIG_fail;
23229 swig_obj[0] = args;
23230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23233 }
23234 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = ((wxMoveEvent const *)arg1)->GetPosition();
23238 wxPyEndAllowThreads(__tstate);
23239 if (PyErr_Occurred()) SWIG_fail;
23240 }
23241 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23242 return resultobj;
23243 fail:
23244 return NULL;
23245 }
23246
23247
23248 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23249 PyObject *resultobj = 0;
23250 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23251 wxRect result;
23252 void *argp1 = 0 ;
23253 int res1 = 0 ;
23254 PyObject *swig_obj[1] ;
23255
23256 if (!args) SWIG_fail;
23257 swig_obj[0] = args;
23258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23261 }
23262 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 result = ((wxMoveEvent const *)arg1)->GetRect();
23266 wxPyEndAllowThreads(__tstate);
23267 if (PyErr_Occurred()) SWIG_fail;
23268 }
23269 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23277 PyObject *resultobj = 0;
23278 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23279 wxRect *arg2 = 0 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 wxRect temp2 ;
23283 PyObject * obj0 = 0 ;
23284 PyObject * obj1 = 0 ;
23285 char * kwnames[] = {
23286 (char *) "self",(char *) "rect", NULL
23287 };
23288
23289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23291 if (!SWIG_IsOK(res1)) {
23292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23293 }
23294 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23295 {
23296 arg2 = &temp2;
23297 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23298 }
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 (arg1)->SetRect((wxRect const &)*arg2);
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 resultobj = SWIG_Py_Void();
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj = 0;
23314 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23315 wxPoint *arg2 = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 wxPoint temp2 ;
23319 PyObject * obj0 = 0 ;
23320 PyObject * obj1 = 0 ;
23321 char * kwnames[] = {
23322 (char *) "self",(char *) "pos", NULL
23323 };
23324
23325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23327 if (!SWIG_IsOK(res1)) {
23328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23329 }
23330 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23331 {
23332 arg2 = &temp2;
23333 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23334 }
23335 {
23336 PyThreadState* __tstate = wxPyBeginAllowThreads();
23337 (arg1)->SetPosition((wxPoint const &)*arg2);
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 resultobj = SWIG_Py_Void();
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23349 PyObject *obj;
23350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23351 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23352 return SWIG_Py_Void();
23353 }
23354
23355 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23356 return SWIG_Python_InitShadowInstance(args);
23357 }
23358
23359 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 int arg1 = (int) 0 ;
23362 wxPaintEvent *result = 0 ;
23363 int val1 ;
23364 int ecode1 = 0 ;
23365 PyObject * obj0 = 0 ;
23366 char * kwnames[] = {
23367 (char *) "Id", NULL
23368 };
23369
23370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23371 if (obj0) {
23372 ecode1 = SWIG_AsVal_int(obj0, &val1);
23373 if (!SWIG_IsOK(ecode1)) {
23374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23375 }
23376 arg1 = static_cast< int >(val1);
23377 }
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23392 PyObject *obj;
23393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23395 return SWIG_Py_Void();
23396 }
23397
23398 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399 return SWIG_Python_InitShadowInstance(args);
23400 }
23401
23402 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj = 0;
23404 int arg1 = (int) 0 ;
23405 wxNcPaintEvent *result = 0 ;
23406 int val1 ;
23407 int ecode1 = 0 ;
23408 PyObject * obj0 = 0 ;
23409 char * kwnames[] = {
23410 (char *) "winid", NULL
23411 };
23412
23413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23414 if (obj0) {
23415 ecode1 = SWIG_AsVal_int(obj0, &val1);
23416 if (!SWIG_IsOK(ecode1)) {
23417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23418 }
23419 arg1 = static_cast< int >(val1);
23420 }
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *obj;
23436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23437 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23438 return SWIG_Py_Void();
23439 }
23440
23441 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 return SWIG_Python_InitShadowInstance(args);
23443 }
23444
23445 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = 0;
23447 int arg1 = (int) 0 ;
23448 wxDC *arg2 = (wxDC *) NULL ;
23449 wxEraseEvent *result = 0 ;
23450 int val1 ;
23451 int ecode1 = 0 ;
23452 void *argp2 = 0 ;
23453 int res2 = 0 ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "Id",(char *) "dc", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23461 if (obj0) {
23462 ecode1 = SWIG_AsVal_int(obj0, &val1);
23463 if (!SWIG_IsOK(ecode1)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23465 }
23466 arg1 = static_cast< int >(val1);
23467 }
23468 if (obj1) {
23469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23470 if (!SWIG_IsOK(res2)) {
23471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23472 }
23473 arg2 = reinterpret_cast< wxDC * >(argp2);
23474 }
23475 {
23476 PyThreadState* __tstate = wxPyBeginAllowThreads();
23477 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23482 return resultobj;
23483 fail:
23484 return NULL;
23485 }
23486
23487
23488 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23489 PyObject *resultobj = 0;
23490 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23491 wxDC *result = 0 ;
23492 void *argp1 = 0 ;
23493 int res1 = 0 ;
23494 PyObject *swig_obj[1] ;
23495
23496 if (!args) SWIG_fail;
23497 swig_obj[0] = args;
23498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23499 if (!SWIG_IsOK(res1)) {
23500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23501 }
23502 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 {
23510 resultobj = wxPyMake_wxObject(result, (bool)0);
23511 }
23512 return resultobj;
23513 fail:
23514 return NULL;
23515 }
23516
23517
23518 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23519 PyObject *obj;
23520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23521 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23522 return SWIG_Py_Void();
23523 }
23524
23525 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23526 return SWIG_Python_InitShadowInstance(args);
23527 }
23528
23529 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj = 0;
23531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23532 int arg2 = (int) 0 ;
23533 wxFocusEvent *result = 0 ;
23534 int val1 ;
23535 int ecode1 = 0 ;
23536 int val2 ;
23537 int ecode2 = 0 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char * kwnames[] = {
23541 (char *) "type",(char *) "winid", NULL
23542 };
23543
23544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23545 if (obj0) {
23546 ecode1 = SWIG_AsVal_int(obj0, &val1);
23547 if (!SWIG_IsOK(ecode1)) {
23548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23549 }
23550 arg1 = static_cast< wxEventType >(val1);
23551 }
23552 if (obj1) {
23553 ecode2 = SWIG_AsVal_int(obj1, &val2);
23554 if (!SWIG_IsOK(ecode2)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23556 }
23557 arg2 = static_cast< int >(val2);
23558 }
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 PyObject *resultobj = 0;
23574 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23575 wxWindow *result = 0 ;
23576 void *argp1 = 0 ;
23577 int res1 = 0 ;
23578 PyObject *swig_obj[1] ;
23579
23580 if (!args) SWIG_fail;
23581 swig_obj[0] = args;
23582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23585 }
23586 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 resultobj = wxPyMake_wxObject(result, (bool)0);
23595 }
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj = 0;
23604 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23605 wxWindow *arg2 = (wxWindow *) 0 ;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 void *argp2 = 0 ;
23609 int res2 = 0 ;
23610 PyObject * obj0 = 0 ;
23611 PyObject * obj1 = 0 ;
23612 char * kwnames[] = {
23613 (char *) "self",(char *) "win", NULL
23614 };
23615
23616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23620 }
23621 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23623 if (!SWIG_IsOK(res2)) {
23624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23625 }
23626 arg2 = reinterpret_cast< wxWindow * >(argp2);
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 (arg1)->SetWindow(arg2);
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_Py_Void();
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641 PyObject *obj;
23642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23643 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23644 return SWIG_Py_Void();
23645 }
23646
23647 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 return SWIG_Python_InitShadowInstance(args);
23649 }
23650
23651 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj = 0;
23653 wxWindow *arg1 = (wxWindow *) NULL ;
23654 wxChildFocusEvent *result = 0 ;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 PyObject * obj0 = 0 ;
23658 char * kwnames[] = {
23659 (char *) "win", NULL
23660 };
23661
23662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23663 if (obj0) {
23664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23665 if (!SWIG_IsOK(res1)) {
23666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23667 }
23668 arg1 = reinterpret_cast< wxWindow * >(argp1);
23669 }
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23684 PyObject *resultobj = 0;
23685 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23686 wxWindow *result = 0 ;
23687 void *argp1 = 0 ;
23688 int res1 = 0 ;
23689 PyObject *swig_obj[1] ;
23690
23691 if (!args) SWIG_fail;
23692 swig_obj[0] = args;
23693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23694 if (!SWIG_IsOK(res1)) {
23695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23696 }
23697 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23701 wxPyEndAllowThreads(__tstate);
23702 if (PyErr_Occurred()) SWIG_fail;
23703 }
23704 {
23705 resultobj = wxPyMake_wxObject(result, (bool)0);
23706 }
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *obj;
23715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23716 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23717 return SWIG_Py_Void();
23718 }
23719
23720 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 return SWIG_Python_InitShadowInstance(args);
23722 }
23723
23724 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23727 bool arg2 = (bool) true ;
23728 int arg3 = (int) 0 ;
23729 wxActivateEvent *result = 0 ;
23730 int val1 ;
23731 int ecode1 = 0 ;
23732 bool val2 ;
23733 int ecode2 = 0 ;
23734 int val3 ;
23735 int ecode3 = 0 ;
23736 PyObject * obj0 = 0 ;
23737 PyObject * obj1 = 0 ;
23738 PyObject * obj2 = 0 ;
23739 char * kwnames[] = {
23740 (char *) "type",(char *) "active",(char *) "Id", NULL
23741 };
23742
23743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23744 if (obj0) {
23745 ecode1 = SWIG_AsVal_int(obj0, &val1);
23746 if (!SWIG_IsOK(ecode1)) {
23747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23748 }
23749 arg1 = static_cast< wxEventType >(val1);
23750 }
23751 if (obj1) {
23752 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23753 if (!SWIG_IsOK(ecode2)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23755 }
23756 arg2 = static_cast< bool >(val2);
23757 }
23758 if (obj2) {
23759 ecode3 = SWIG_AsVal_int(obj2, &val3);
23760 if (!SWIG_IsOK(ecode3)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23762 }
23763 arg3 = static_cast< int >(val3);
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23779 PyObject *resultobj = 0;
23780 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23781 bool result;
23782 void *argp1 = 0 ;
23783 int res1 = 0 ;
23784 PyObject *swig_obj[1] ;
23785
23786 if (!args) SWIG_fail;
23787 swig_obj[0] = args;
23788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23789 if (!SWIG_IsOK(res1)) {
23790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23791 }
23792 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 int arg1 = (int) 0 ;
23822 wxInitDialogEvent *result = 0 ;
23823 int val1 ;
23824 int ecode1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "Id", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23831 if (obj0) {
23832 ecode1 = SWIG_AsVal_int(obj0, &val1);
23833 if (!SWIG_IsOK(ecode1)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23835 }
23836 arg1 = static_cast< int >(val1);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *obj;
23853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23854 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23855 return SWIG_Py_Void();
23856 }
23857
23858 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23859 return SWIG_Python_InitShadowInstance(args);
23860 }
23861
23862 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj = 0;
23864 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23865 int arg2 = (int) 0 ;
23866 wxMenu *arg3 = (wxMenu *) NULL ;
23867 wxMenuEvent *result = 0 ;
23868 int val1 ;
23869 int ecode1 = 0 ;
23870 int val2 ;
23871 int ecode2 = 0 ;
23872 void *argp3 = 0 ;
23873 int res3 = 0 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 PyObject * obj2 = 0 ;
23877 char * kwnames[] = {
23878 (char *) "type",(char *) "winid",(char *) "menu", NULL
23879 };
23880
23881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23882 if (obj0) {
23883 ecode1 = SWIG_AsVal_int(obj0, &val1);
23884 if (!SWIG_IsOK(ecode1)) {
23885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23886 }
23887 arg1 = static_cast< wxEventType >(val1);
23888 }
23889 if (obj1) {
23890 ecode2 = SWIG_AsVal_int(obj1, &val2);
23891 if (!SWIG_IsOK(ecode2)) {
23892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23893 }
23894 arg2 = static_cast< int >(val2);
23895 }
23896 if (obj2) {
23897 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23898 if (!SWIG_IsOK(res3)) {
23899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23900 }
23901 arg3 = reinterpret_cast< wxMenu * >(argp3);
23902 }
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23906 wxPyEndAllowThreads(__tstate);
23907 if (PyErr_Occurred()) SWIG_fail;
23908 }
23909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23910 return resultobj;
23911 fail:
23912 return NULL;
23913 }
23914
23915
23916 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23917 PyObject *resultobj = 0;
23918 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23919 int result;
23920 void *argp1 = 0 ;
23921 int res1 = 0 ;
23922 PyObject *swig_obj[1] ;
23923
23924 if (!args) SWIG_fail;
23925 swig_obj[0] = args;
23926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23927 if (!SWIG_IsOK(res1)) {
23928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23929 }
23930 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 resultobj = SWIG_From_int(static_cast< int >(result));
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23945 PyObject *resultobj = 0;
23946 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23947 bool result;
23948 void *argp1 = 0 ;
23949 int res1 = 0 ;
23950 PyObject *swig_obj[1] ;
23951
23952 if (!args) SWIG_fail;
23953 swig_obj[0] = args;
23954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23955 if (!SWIG_IsOK(res1)) {
23956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23957 }
23958 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 {
23966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23967 }
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23975 PyObject *resultobj = 0;
23976 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23977 wxMenu *result = 0 ;
23978 void *argp1 = 0 ;
23979 int res1 = 0 ;
23980 PyObject *swig_obj[1] ;
23981
23982 if (!args) SWIG_fail;
23983 swig_obj[0] = args;
23984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23985 if (!SWIG_IsOK(res1)) {
23986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23987 }
23988 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23989 {
23990 PyThreadState* __tstate = wxPyBeginAllowThreads();
23991 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 resultobj = wxPyMake_wxObject(result, (bool)0);
23997 }
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *obj;
24006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24008 return SWIG_Py_Void();
24009 }
24010
24011 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 return SWIG_Python_InitShadowInstance(args);
24013 }
24014
24015 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj = 0;
24017 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24018 int arg2 = (int) 0 ;
24019 wxCloseEvent *result = 0 ;
24020 int val1 ;
24021 int ecode1 = 0 ;
24022 int val2 ;
24023 int ecode2 = 0 ;
24024 PyObject * obj0 = 0 ;
24025 PyObject * obj1 = 0 ;
24026 char * kwnames[] = {
24027 (char *) "type",(char *) "winid", NULL
24028 };
24029
24030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24031 if (obj0) {
24032 ecode1 = SWIG_AsVal_int(obj0, &val1);
24033 if (!SWIG_IsOK(ecode1)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24035 }
24036 arg1 = static_cast< wxEventType >(val1);
24037 }
24038 if (obj1) {
24039 ecode2 = SWIG_AsVal_int(obj1, &val2);
24040 if (!SWIG_IsOK(ecode2)) {
24041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24042 }
24043 arg2 = static_cast< int >(val2);
24044 }
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24048 wxPyEndAllowThreads(__tstate);
24049 if (PyErr_Occurred()) SWIG_fail;
24050 }
24051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24059 PyObject *resultobj = 0;
24060 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24061 bool arg2 ;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 bool val2 ;
24065 int ecode2 = 0 ;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 char * kwnames[] = {
24069 (char *) "self",(char *) "logOff", NULL
24070 };
24071
24072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24076 }
24077 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24079 if (!SWIG_IsOK(ecode2)) {
24080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24081 }
24082 arg2 = static_cast< bool >(val2);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 (arg1)->SetLoggingOff(arg2);
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_Py_Void();
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24099 bool result;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24109 }
24110 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 {
24118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24119 }
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj = 0;
24128 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24129 bool arg2 = (bool) true ;
24130 void *argp1 = 0 ;
24131 int res1 = 0 ;
24132 bool val2 ;
24133 int ecode2 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 char * kwnames[] = {
24137 (char *) "self",(char *) "veto", NULL
24138 };
24139
24140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24142 if (!SWIG_IsOK(res1)) {
24143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24144 }
24145 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24146 if (obj1) {
24147 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24148 if (!SWIG_IsOK(ecode2)) {
24149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24150 }
24151 arg2 = static_cast< bool >(val2);
24152 }
24153 {
24154 PyThreadState* __tstate = wxPyBeginAllowThreads();
24155 (arg1)->Veto(arg2);
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 resultobj = SWIG_Py_Void();
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24167 PyObject *resultobj = 0;
24168 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24169 bool result;
24170 void *argp1 = 0 ;
24171 int res1 = 0 ;
24172 PyObject *swig_obj[1] ;
24173
24174 if (!args) SWIG_fail;
24175 swig_obj[0] = args;
24176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24177 if (!SWIG_IsOK(res1)) {
24178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24179 }
24180 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 {
24188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24189 }
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24197 PyObject *resultobj = 0;
24198 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24199 bool arg2 ;
24200 void *argp1 = 0 ;
24201 int res1 = 0 ;
24202 bool val2 ;
24203 int ecode2 = 0 ;
24204 PyObject * obj0 = 0 ;
24205 PyObject * obj1 = 0 ;
24206 char * kwnames[] = {
24207 (char *) "self",(char *) "canVeto", NULL
24208 };
24209
24210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24212 if (!SWIG_IsOK(res1)) {
24213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24214 }
24215 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24217 if (!SWIG_IsOK(ecode2)) {
24218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24219 }
24220 arg2 = static_cast< bool >(val2);
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 (arg1)->SetCanVeto(arg2);
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 resultobj = SWIG_Py_Void();
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24235 PyObject *resultobj = 0;
24236 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24237 bool result;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 PyObject *swig_obj[1] ;
24241
24242 if (!args) SWIG_fail;
24243 swig_obj[0] = args;
24244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24247 }
24248 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *obj;
24266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24267 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24268 return SWIG_Py_Void();
24269 }
24270
24271 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 return SWIG_Python_InitShadowInstance(args);
24273 }
24274
24275 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24276 PyObject *resultobj = 0;
24277 int arg1 = (int) 0 ;
24278 bool arg2 = (bool) false ;
24279 wxShowEvent *result = 0 ;
24280 int val1 ;
24281 int ecode1 = 0 ;
24282 bool val2 ;
24283 int ecode2 = 0 ;
24284 PyObject * obj0 = 0 ;
24285 PyObject * obj1 = 0 ;
24286 char * kwnames[] = {
24287 (char *) "winid",(char *) "show", NULL
24288 };
24289
24290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24291 if (obj0) {
24292 ecode1 = SWIG_AsVal_int(obj0, &val1);
24293 if (!SWIG_IsOK(ecode1)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24295 }
24296 arg1 = static_cast< int >(val1);
24297 }
24298 if (obj1) {
24299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24300 if (!SWIG_IsOK(ecode2)) {
24301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24302 }
24303 arg2 = static_cast< bool >(val2);
24304 }
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj = 0;
24320 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24321 bool arg2 ;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 bool val2 ;
24325 int ecode2 = 0 ;
24326 PyObject * obj0 = 0 ;
24327 PyObject * obj1 = 0 ;
24328 char * kwnames[] = {
24329 (char *) "self",(char *) "show", NULL
24330 };
24331
24332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24334 if (!SWIG_IsOK(res1)) {
24335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24336 }
24337 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24338 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24339 if (!SWIG_IsOK(ecode2)) {
24340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24341 }
24342 arg2 = static_cast< bool >(val2);
24343 {
24344 PyThreadState* __tstate = wxPyBeginAllowThreads();
24345 (arg1)->SetShow(arg2);
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 resultobj = SWIG_Py_Void();
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24357 PyObject *resultobj = 0;
24358 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24359 bool result;
24360 void *argp1 = 0 ;
24361 int res1 = 0 ;
24362 PyObject *swig_obj[1] ;
24363
24364 if (!args) SWIG_fail;
24365 swig_obj[0] = args;
24366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24369 }
24370 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24371 {
24372 PyThreadState* __tstate = wxPyBeginAllowThreads();
24373 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24374 wxPyEndAllowThreads(__tstate);
24375 if (PyErr_Occurred()) SWIG_fail;
24376 }
24377 {
24378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24379 }
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *obj;
24388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24389 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24390 return SWIG_Py_Void();
24391 }
24392
24393 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 return SWIG_Python_InitShadowInstance(args);
24395 }
24396
24397 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj = 0;
24399 int arg1 = (int) 0 ;
24400 bool arg2 = (bool) true ;
24401 wxIconizeEvent *result = 0 ;
24402 int val1 ;
24403 int ecode1 = 0 ;
24404 bool val2 ;
24405 int ecode2 = 0 ;
24406 PyObject * obj0 = 0 ;
24407 PyObject * obj1 = 0 ;
24408 char * kwnames[] = {
24409 (char *) "id",(char *) "iconized", NULL
24410 };
24411
24412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24413 if (obj0) {
24414 ecode1 = SWIG_AsVal_int(obj0, &val1);
24415 if (!SWIG_IsOK(ecode1)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24417 }
24418 arg1 = static_cast< int >(val1);
24419 }
24420 if (obj1) {
24421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24422 if (!SWIG_IsOK(ecode2)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24424 }
24425 arg2 = static_cast< bool >(val2);
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 PyObject *resultobj = 0;
24442 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24443 bool result;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 PyObject *swig_obj[1] ;
24447
24448 if (!args) SWIG_fail;
24449 swig_obj[0] = args;
24450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24453 }
24454 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (bool)(arg1)->Iconized();
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24471 PyObject *obj;
24472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24473 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24474 return SWIG_Py_Void();
24475 }
24476
24477 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 return SWIG_Python_InitShadowInstance(args);
24479 }
24480
24481 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 int arg1 = (int) 0 ;
24484 wxMaximizeEvent *result = 0 ;
24485 int val1 ;
24486 int ecode1 = 0 ;
24487 PyObject * obj0 = 0 ;
24488 char * kwnames[] = {
24489 (char *) "id", NULL
24490 };
24491
24492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24493 if (obj0) {
24494 ecode1 = SWIG_AsVal_int(obj0, &val1);
24495 if (!SWIG_IsOK(ecode1)) {
24496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24497 }
24498 arg1 = static_cast< int >(val1);
24499 }
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24503 wxPyEndAllowThreads(__tstate);
24504 if (PyErr_Occurred()) SWIG_fail;
24505 }
24506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24507 return resultobj;
24508 fail:
24509 return NULL;
24510 }
24511
24512
24513 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24514 PyObject *obj;
24515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24516 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24517 return SWIG_Py_Void();
24518 }
24519
24520 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521 return SWIG_Python_InitShadowInstance(args);
24522 }
24523
24524 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24527 wxPoint result;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24537 }
24538 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (arg1)->GetPosition();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24546 return resultobj;
24547 fail:
24548 return NULL;
24549 }
24550
24551
24552 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24553 PyObject *resultobj = 0;
24554 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24555 int result;
24556 void *argp1 = 0 ;
24557 int res1 = 0 ;
24558 PyObject *swig_obj[1] ;
24559
24560 if (!args) SWIG_fail;
24561 swig_obj[0] = args;
24562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24565 }
24566 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24567 {
24568 PyThreadState* __tstate = wxPyBeginAllowThreads();
24569 result = (int)(arg1)->GetNumberOfFiles();
24570 wxPyEndAllowThreads(__tstate);
24571 if (PyErr_Occurred()) SWIG_fail;
24572 }
24573 resultobj = SWIG_From_int(static_cast< int >(result));
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24581 PyObject *resultobj = 0;
24582 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24583 PyObject *result = 0 ;
24584 void *argp1 = 0 ;
24585 int res1 = 0 ;
24586 PyObject *swig_obj[1] ;
24587
24588 if (!args) SWIG_fail;
24589 swig_obj[0] = args;
24590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24591 if (!SWIG_IsOK(res1)) {
24592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24593 }
24594 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = result;
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24609 PyObject *obj;
24610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24611 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24612 return SWIG_Py_Void();
24613 }
24614
24615 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 int arg1 = (int) 0 ;
24618 wxUpdateUIEvent *result = 0 ;
24619 int val1 ;
24620 int ecode1 = 0 ;
24621 PyObject * obj0 = 0 ;
24622 char * kwnames[] = {
24623 (char *) "commandId", NULL
24624 };
24625
24626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24627 if (obj0) {
24628 ecode1 = SWIG_AsVal_int(obj0, &val1);
24629 if (!SWIG_IsOK(ecode1)) {
24630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24631 }
24632 arg1 = static_cast< int >(val1);
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24648 PyObject *resultobj = 0;
24649 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24650 bool result;
24651 void *argp1 = 0 ;
24652 int res1 = 0 ;
24653 PyObject *swig_obj[1] ;
24654
24655 if (!args) SWIG_fail;
24656 swig_obj[0] = args;
24657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24658 if (!SWIG_IsOK(res1)) {
24659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24660 }
24661 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24665 wxPyEndAllowThreads(__tstate);
24666 if (PyErr_Occurred()) SWIG_fail;
24667 }
24668 {
24669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24670 }
24671 return resultobj;
24672 fail:
24673 return NULL;
24674 }
24675
24676
24677 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 PyObject *resultobj = 0;
24679 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24680 bool result;
24681 void *argp1 = 0 ;
24682 int res1 = 0 ;
24683 PyObject *swig_obj[1] ;
24684
24685 if (!args) SWIG_fail;
24686 swig_obj[0] = args;
24687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24690 }
24691 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 {
24699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24700 }
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24708 PyObject *resultobj = 0;
24709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24710 bool result;
24711 void *argp1 = 0 ;
24712 int res1 = 0 ;
24713 PyObject *swig_obj[1] ;
24714
24715 if (!args) SWIG_fail;
24716 swig_obj[0] = args;
24717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24720 }
24721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 {
24729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24730 }
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24738 PyObject *resultobj = 0;
24739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24740 wxString result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 PyObject *swig_obj[1] ;
24744
24745 if (!args) SWIG_fail;
24746 swig_obj[0] = args;
24747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24748 if (!SWIG_IsOK(res1)) {
24749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24750 }
24751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 #if wxUSE_UNICODE
24760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24761 #else
24762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24763 #endif
24764 }
24765 return resultobj;
24766 fail:
24767 return NULL;
24768 }
24769
24770
24771 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24772 PyObject *resultobj = 0;
24773 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24774 bool result;
24775 void *argp1 = 0 ;
24776 int res1 = 0 ;
24777 PyObject *swig_obj[1] ;
24778
24779 if (!args) SWIG_fail;
24780 swig_obj[0] = args;
24781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24782 if (!SWIG_IsOK(res1)) {
24783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24784 }
24785 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 {
24793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24794 }
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24802 PyObject *resultobj = 0;
24803 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24804 bool result;
24805 void *argp1 = 0 ;
24806 int res1 = 0 ;
24807 PyObject *swig_obj[1] ;
24808
24809 if (!args) SWIG_fail;
24810 swig_obj[0] = args;
24811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24812 if (!SWIG_IsOK(res1)) {
24813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24814 }
24815 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24832 PyObject *resultobj = 0;
24833 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24834 bool result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 PyObject *swig_obj[1] ;
24838
24839 if (!args) SWIG_fail;
24840 swig_obj[0] = args;
24841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24842 if (!SWIG_IsOK(res1)) {
24843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24844 }
24845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24864 bool result;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 PyObject *swig_obj[1] ;
24868
24869 if (!args) SWIG_fail;
24870 swig_obj[0] = args;
24871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 {
24883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24892 PyObject *resultobj = 0;
24893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24894 bool arg2 ;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 bool val2 ;
24898 int ecode2 = 0 ;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 char * kwnames[] = {
24902 (char *) "self",(char *) "check", NULL
24903 };
24904
24905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24909 }
24910 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24912 if (!SWIG_IsOK(ecode2)) {
24913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24914 }
24915 arg2 = static_cast< bool >(val2);
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 (arg1)->Check(arg2);
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_Py_Void();
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24932 bool arg2 ;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 bool val2 ;
24936 int ecode2 = 0 ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "enable", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24947 }
24948 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24950 if (!SWIG_IsOK(ecode2)) {
24951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24952 }
24953 arg2 = static_cast< bool >(val2);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 (arg1)->Enable(arg2);
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 resultobj = SWIG_Py_Void();
24961 return resultobj;
24962 fail:
24963 return NULL;
24964 }
24965
24966
24967 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj = 0;
24969 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24970 bool arg2 ;
24971 void *argp1 = 0 ;
24972 int res1 = 0 ;
24973 bool val2 ;
24974 int ecode2 = 0 ;
24975 PyObject * obj0 = 0 ;
24976 PyObject * obj1 = 0 ;
24977 char * kwnames[] = {
24978 (char *) "self",(char *) "show", NULL
24979 };
24980
24981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24985 }
24986 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24988 if (!SWIG_IsOK(ecode2)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24990 }
24991 arg2 = static_cast< bool >(val2);
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 (arg1)->Show(arg2);
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_Py_Void();
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25006 PyObject *resultobj = 0;
25007 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25008 wxString *arg2 = 0 ;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 bool temp2 = false ;
25012 PyObject * obj0 = 0 ;
25013 PyObject * obj1 = 0 ;
25014 char * kwnames[] = {
25015 (char *) "self",(char *) "text", NULL
25016 };
25017
25018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25020 if (!SWIG_IsOK(res1)) {
25021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25022 }
25023 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25024 {
25025 arg2 = wxString_in_helper(obj1);
25026 if (arg2 == NULL) SWIG_fail;
25027 temp2 = true;
25028 }
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 (arg1)->SetText((wxString const &)*arg2);
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 resultobj = SWIG_Py_Void();
25036 {
25037 if (temp2)
25038 delete arg2;
25039 }
25040 return resultobj;
25041 fail:
25042 {
25043 if (temp2)
25044 delete arg2;
25045 }
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj = 0;
25052 long arg1 ;
25053 long val1 ;
25054 int ecode1 = 0 ;
25055 PyObject * obj0 = 0 ;
25056 char * kwnames[] = {
25057 (char *) "updateInterval", NULL
25058 };
25059
25060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25061 ecode1 = SWIG_AsVal_long(obj0, &val1);
25062 if (!SWIG_IsOK(ecode1)) {
25063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25064 }
25065 arg1 = static_cast< long >(val1);
25066 {
25067 PyThreadState* __tstate = wxPyBeginAllowThreads();
25068 wxUpdateUIEvent::SetUpdateInterval(arg1);
25069 wxPyEndAllowThreads(__tstate);
25070 if (PyErr_Occurred()) SWIG_fail;
25071 }
25072 resultobj = SWIG_Py_Void();
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 long result;
25082
25083 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_From_long(static_cast< long >(result));
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxWindow *arg1 = (wxWindow *) 0 ;
25100 bool result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 PyObject * obj0 = 0 ;
25104 char * kwnames[] = {
25105 (char *) "win", NULL
25106 };
25107
25108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25110 if (!SWIG_IsOK(res1)) {
25111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25112 }
25113 arg1 = reinterpret_cast< wxWindow * >(argp1);
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 {
25121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25122 }
25123 return resultobj;
25124 fail:
25125 return NULL;
25126 }
25127
25128
25129 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 PyObject *resultobj = 0;
25131
25132 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 wxUpdateUIEvent::ResetUpdateTime();
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 resultobj = SWIG_Py_Void();
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj = 0;
25148 wxUpdateUIMode arg1 ;
25149 int val1 ;
25150 int ecode1 = 0 ;
25151 PyObject * obj0 = 0 ;
25152 char * kwnames[] = {
25153 (char *) "mode", NULL
25154 };
25155
25156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25157 ecode1 = SWIG_AsVal_int(obj0, &val1);
25158 if (!SWIG_IsOK(ecode1)) {
25159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25160 }
25161 arg1 = static_cast< wxUpdateUIMode >(val1);
25162 {
25163 PyThreadState* __tstate = wxPyBeginAllowThreads();
25164 wxUpdateUIEvent::SetMode(arg1);
25165 wxPyEndAllowThreads(__tstate);
25166 if (PyErr_Occurred()) SWIG_fail;
25167 }
25168 resultobj = SWIG_Py_Void();
25169 return resultobj;
25170 fail:
25171 return NULL;
25172 }
25173
25174
25175 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25176 PyObject *resultobj = 0;
25177 wxUpdateUIMode result;
25178
25179 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_From_int(static_cast< int >(result));
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25194 PyObject *obj;
25195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25196 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25197 return SWIG_Py_Void();
25198 }
25199
25200 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 return SWIG_Python_InitShadowInstance(args);
25202 }
25203
25204 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25205 PyObject *resultobj = 0;
25206 wxSysColourChangedEvent *result = 0 ;
25207
25208 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25209 {
25210 PyThreadState* __tstate = wxPyBeginAllowThreads();
25211 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25216 return resultobj;
25217 fail:
25218 return NULL;
25219 }
25220
25221
25222 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 PyObject *obj;
25224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25225 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25226 return SWIG_Py_Void();
25227 }
25228
25229 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25230 return SWIG_Python_InitShadowInstance(args);
25231 }
25232
25233 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj = 0;
25235 int arg1 = (int) 0 ;
25236 wxWindow *arg2 = (wxWindow *) NULL ;
25237 wxMouseCaptureChangedEvent *result = 0 ;
25238 int val1 ;
25239 int ecode1 = 0 ;
25240 void *argp2 = 0 ;
25241 int res2 = 0 ;
25242 PyObject * obj0 = 0 ;
25243 PyObject * obj1 = 0 ;
25244 char * kwnames[] = {
25245 (char *) "winid",(char *) "gainedCapture", NULL
25246 };
25247
25248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25249 if (obj0) {
25250 ecode1 = SWIG_AsVal_int(obj0, &val1);
25251 if (!SWIG_IsOK(ecode1)) {
25252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25253 }
25254 arg1 = static_cast< int >(val1);
25255 }
25256 if (obj1) {
25257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25258 if (!SWIG_IsOK(res2)) {
25259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25260 }
25261 arg2 = reinterpret_cast< wxWindow * >(argp2);
25262 }
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 PyObject *resultobj = 0;
25278 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25279 wxWindow *result = 0 ;
25280 void *argp1 = 0 ;
25281 int res1 = 0 ;
25282 PyObject *swig_obj[1] ;
25283
25284 if (!args) SWIG_fail;
25285 swig_obj[0] = args;
25286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25289 }
25290 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 {
25298 resultobj = wxPyMake_wxObject(result, (bool)0);
25299 }
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25307 PyObject *obj;
25308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25309 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25310 return SWIG_Py_Void();
25311 }
25312
25313 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25314 return SWIG_Python_InitShadowInstance(args);
25315 }
25316
25317 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25318 PyObject *resultobj = 0;
25319 wxDisplayChangedEvent *result = 0 ;
25320
25321 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *obj;
25337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25338 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25339 return SWIG_Py_Void();
25340 }
25341
25342 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 return SWIG_Python_InitShadowInstance(args);
25344 }
25345
25346 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25347 PyObject *resultobj = 0;
25348 int arg1 = (int) 0 ;
25349 wxPaletteChangedEvent *result = 0 ;
25350 int val1 ;
25351 int ecode1 = 0 ;
25352 PyObject * obj0 = 0 ;
25353 char * kwnames[] = {
25354 (char *) "id", NULL
25355 };
25356
25357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25358 if (obj0) {
25359 ecode1 = SWIG_AsVal_int(obj0, &val1);
25360 if (!SWIG_IsOK(ecode1)) {
25361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25362 }
25363 arg1 = static_cast< int >(val1);
25364 }
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj = 0;
25380 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25381 wxWindow *arg2 = (wxWindow *) 0 ;
25382 void *argp1 = 0 ;
25383 int res1 = 0 ;
25384 void *argp2 = 0 ;
25385 int res2 = 0 ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 char * kwnames[] = {
25389 (char *) "self",(char *) "win", NULL
25390 };
25391
25392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25394 if (!SWIG_IsOK(res1)) {
25395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25396 }
25397 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25399 if (!SWIG_IsOK(res2)) {
25400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25401 }
25402 arg2 = reinterpret_cast< wxWindow * >(argp2);
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 (arg1)->SetChangedWindow(arg2);
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 resultobj = SWIG_Py_Void();
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25417 PyObject *resultobj = 0;
25418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25419 wxWindow *result = 0 ;
25420 void *argp1 = 0 ;
25421 int res1 = 0 ;
25422 PyObject *swig_obj[1] ;
25423
25424 if (!args) SWIG_fail;
25425 swig_obj[0] = args;
25426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25427 if (!SWIG_IsOK(res1)) {
25428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25429 }
25430 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (wxWindow *)(arg1)->GetChangedWindow();
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 {
25438 resultobj = wxPyMake_wxObject(result, (bool)0);
25439 }
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25447 PyObject *obj;
25448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25449 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25450 return SWIG_Py_Void();
25451 }
25452
25453 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25454 return SWIG_Python_InitShadowInstance(args);
25455 }
25456
25457 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25458 PyObject *resultobj = 0;
25459 int arg1 = (int) 0 ;
25460 wxQueryNewPaletteEvent *result = 0 ;
25461 int val1 ;
25462 int ecode1 = 0 ;
25463 PyObject * obj0 = 0 ;
25464 char * kwnames[] = {
25465 (char *) "winid", NULL
25466 };
25467
25468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25469 if (obj0) {
25470 ecode1 = SWIG_AsVal_int(obj0, &val1);
25471 if (!SWIG_IsOK(ecode1)) {
25472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25473 }
25474 arg1 = static_cast< int >(val1);
25475 }
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25483 return resultobj;
25484 fail:
25485 return NULL;
25486 }
25487
25488
25489 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25490 PyObject *resultobj = 0;
25491 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25492 bool arg2 ;
25493 void *argp1 = 0 ;
25494 int res1 = 0 ;
25495 bool val2 ;
25496 int ecode2 = 0 ;
25497 PyObject * obj0 = 0 ;
25498 PyObject * obj1 = 0 ;
25499 char * kwnames[] = {
25500 (char *) "self",(char *) "realized", NULL
25501 };
25502
25503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25507 }
25508 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25510 if (!SWIG_IsOK(ecode2)) {
25511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25512 }
25513 arg2 = static_cast< bool >(val2);
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 (arg1)->SetPaletteRealized(arg2);
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 resultobj = SWIG_Py_Void();
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25528 PyObject *resultobj = 0;
25529 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25530 bool result;
25531 void *argp1 = 0 ;
25532 int res1 = 0 ;
25533 PyObject *swig_obj[1] ;
25534
25535 if (!args) SWIG_fail;
25536 swig_obj[0] = args;
25537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25538 if (!SWIG_IsOK(res1)) {
25539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25540 }
25541 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 {
25549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25550 }
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25558 PyObject *obj;
25559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25560 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25561 return SWIG_Py_Void();
25562 }
25563
25564 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25565 return SWIG_Python_InitShadowInstance(args);
25566 }
25567
25568 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25569 PyObject *resultobj = 0;
25570 wxNavigationKeyEvent *result = 0 ;
25571
25572 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25589 bool result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25599 }
25600 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25604 wxPyEndAllowThreads(__tstate);
25605 if (PyErr_Occurred()) SWIG_fail;
25606 }
25607 {
25608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25609 }
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj = 0;
25618 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25619 bool arg2 ;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 bool val2 ;
25623 int ecode2 = 0 ;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 char * kwnames[] = {
25627 (char *) "self",(char *) "forward", NULL
25628 };
25629
25630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25637 if (!SWIG_IsOK(ecode2)) {
25638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25639 }
25640 arg2 = static_cast< bool >(val2);
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 (arg1)->SetDirection(arg2);
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 resultobj = SWIG_Py_Void();
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25655 PyObject *resultobj = 0;
25656 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25657 bool result;
25658 void *argp1 = 0 ;
25659 int res1 = 0 ;
25660 PyObject *swig_obj[1] ;
25661
25662 if (!args) SWIG_fail;
25663 swig_obj[0] = args;
25664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25665 if (!SWIG_IsOK(res1)) {
25666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25667 }
25668 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 {
25676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25677 }
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25685 PyObject *resultobj = 0;
25686 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25687 bool arg2 ;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 bool val2 ;
25691 int ecode2 = 0 ;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char * kwnames[] = {
25695 (char *) "self",(char *) "ischange", NULL
25696 };
25697
25698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25702 }
25703 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25705 if (!SWIG_IsOK(ecode2)) {
25706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25707 }
25708 arg2 = static_cast< bool >(val2);
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 (arg1)->SetWindowChange(arg2);
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 resultobj = SWIG_Py_Void();
25716 return resultobj;
25717 fail:
25718 return NULL;
25719 }
25720
25721
25722 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25723 PyObject *resultobj = 0;
25724 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25725 bool result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 PyObject *swig_obj[1] ;
25729
25730 if (!args) SWIG_fail;
25731 swig_obj[0] = args;
25732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25733 if (!SWIG_IsOK(res1)) {
25734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25735 }
25736 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj = 0;
25754 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25755 bool arg2 ;
25756 void *argp1 = 0 ;
25757 int res1 = 0 ;
25758 bool val2 ;
25759 int ecode2 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 PyObject * obj1 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "self",(char *) "bIs", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25770 }
25771 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25773 if (!SWIG_IsOK(ecode2)) {
25774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25775 }
25776 arg2 = static_cast< bool >(val2);
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 (arg1)->SetFromTab(arg2);
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 resultobj = SWIG_Py_Void();
25784 return resultobj;
25785 fail:
25786 return NULL;
25787 }
25788
25789
25790 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = 0;
25792 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25793 long arg2 ;
25794 void *argp1 = 0 ;
25795 int res1 = 0 ;
25796 long val2 ;
25797 int ecode2 = 0 ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char * kwnames[] = {
25801 (char *) "self",(char *) "flags", NULL
25802 };
25803
25804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25806 if (!SWIG_IsOK(res1)) {
25807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25808 }
25809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25810 ecode2 = SWIG_AsVal_long(obj1, &val2);
25811 if (!SWIG_IsOK(ecode2)) {
25812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25813 }
25814 arg2 = static_cast< long >(val2);
25815 {
25816 PyThreadState* __tstate = wxPyBeginAllowThreads();
25817 (arg1)->SetFlags(arg2);
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 resultobj = SWIG_Py_Void();
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25831 wxWindow *result = 0 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 PyObject *swig_obj[1] ;
25835
25836 if (!args) SWIG_fail;
25837 swig_obj[0] = args;
25838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25839 if (!SWIG_IsOK(res1)) {
25840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25841 }
25842 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 {
25850 resultobj = wxPyMake_wxObject(result, (bool)0);
25851 }
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj = 0;
25860 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25861 wxWindow *arg2 = (wxWindow *) 0 ;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 void *argp2 = 0 ;
25865 int res2 = 0 ;
25866 PyObject * obj0 = 0 ;
25867 PyObject * obj1 = 0 ;
25868 char * kwnames[] = {
25869 (char *) "self",(char *) "win", NULL
25870 };
25871
25872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25874 if (!SWIG_IsOK(res1)) {
25875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25876 }
25877 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25879 if (!SWIG_IsOK(res2)) {
25880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25881 }
25882 arg2 = reinterpret_cast< wxWindow * >(argp2);
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 (arg1)->SetCurrentFocus(arg2);
25886 wxPyEndAllowThreads(__tstate);
25887 if (PyErr_Occurred()) SWIG_fail;
25888 }
25889 resultobj = SWIG_Py_Void();
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25897 PyObject *obj;
25898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25899 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25900 return SWIG_Py_Void();
25901 }
25902
25903 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904 return SWIG_Python_InitShadowInstance(args);
25905 }
25906
25907 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj = 0;
25909 wxWindow *arg1 = (wxWindow *) NULL ;
25910 wxWindowCreateEvent *result = 0 ;
25911 void *argp1 = 0 ;
25912 int res1 = 0 ;
25913 PyObject * obj0 = 0 ;
25914 char * kwnames[] = {
25915 (char *) "win", NULL
25916 };
25917
25918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25919 if (obj0) {
25920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25921 if (!SWIG_IsOK(res1)) {
25922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25923 }
25924 arg1 = reinterpret_cast< wxWindow * >(argp1);
25925 }
25926 {
25927 PyThreadState* __tstate = wxPyBeginAllowThreads();
25928 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25929 wxPyEndAllowThreads(__tstate);
25930 if (PyErr_Occurred()) SWIG_fail;
25931 }
25932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25933 return resultobj;
25934 fail:
25935 return NULL;
25936 }
25937
25938
25939 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25940 PyObject *resultobj = 0;
25941 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25942 wxWindow *result = 0 ;
25943 void *argp1 = 0 ;
25944 int res1 = 0 ;
25945 PyObject *swig_obj[1] ;
25946
25947 if (!args) SWIG_fail;
25948 swig_obj[0] = args;
25949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25950 if (!SWIG_IsOK(res1)) {
25951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25952 }
25953 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 {
25961 resultobj = wxPyMake_wxObject(result, (bool)0);
25962 }
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25970 PyObject *obj;
25971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25972 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25973 return SWIG_Py_Void();
25974 }
25975
25976 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 return SWIG_Python_InitShadowInstance(args);
25978 }
25979
25980 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj = 0;
25982 wxWindow *arg1 = (wxWindow *) NULL ;
25983 wxWindowDestroyEvent *result = 0 ;
25984 void *argp1 = 0 ;
25985 int res1 = 0 ;
25986 PyObject * obj0 = 0 ;
25987 char * kwnames[] = {
25988 (char *) "win", NULL
25989 };
25990
25991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25992 if (obj0) {
25993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25994 if (!SWIG_IsOK(res1)) {
25995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25996 }
25997 arg1 = reinterpret_cast< wxWindow * >(argp1);
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26006 return resultobj;
26007 fail:
26008 return NULL;
26009 }
26010
26011
26012 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26013 PyObject *resultobj = 0;
26014 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26015 wxWindow *result = 0 ;
26016 void *argp1 = 0 ;
26017 int res1 = 0 ;
26018 PyObject *swig_obj[1] ;
26019
26020 if (!args) SWIG_fail;
26021 swig_obj[0] = args;
26022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26023 if (!SWIG_IsOK(res1)) {
26024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26025 }
26026 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 {
26034 resultobj = wxPyMake_wxObject(result, (bool)0);
26035 }
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26043 PyObject *obj;
26044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26045 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26046 return SWIG_Py_Void();
26047 }
26048
26049 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26050 return SWIG_Python_InitShadowInstance(args);
26051 }
26052
26053 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26054 PyObject *resultobj = 0;
26055 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26056 int arg2 = (int) 0 ;
26057 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26058 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26059 wxContextMenuEvent *result = 0 ;
26060 int val1 ;
26061 int ecode1 = 0 ;
26062 int val2 ;
26063 int ecode2 = 0 ;
26064 wxPoint temp3 ;
26065 PyObject * obj0 = 0 ;
26066 PyObject * obj1 = 0 ;
26067 PyObject * obj2 = 0 ;
26068 char * kwnames[] = {
26069 (char *) "type",(char *) "winid",(char *) "pt", NULL
26070 };
26071
26072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26073 if (obj0) {
26074 ecode1 = SWIG_AsVal_int(obj0, &val1);
26075 if (!SWIG_IsOK(ecode1)) {
26076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26077 }
26078 arg1 = static_cast< wxEventType >(val1);
26079 }
26080 if (obj1) {
26081 ecode2 = SWIG_AsVal_int(obj1, &val2);
26082 if (!SWIG_IsOK(ecode2)) {
26083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26084 }
26085 arg2 = static_cast< int >(val2);
26086 }
26087 if (obj2) {
26088 {
26089 arg3 = &temp3;
26090 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26091 }
26092 }
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26109 wxPoint *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26119 }
26120 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 {
26124 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26125 result = (wxPoint *) &_result_ref;
26126 }
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj = 0;
26139 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26140 wxPoint *arg2 = 0 ;
26141 void *argp1 = 0 ;
26142 int res1 = 0 ;
26143 wxPoint temp2 ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "pos", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26154 }
26155 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26156 {
26157 arg2 = &temp2;
26158 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26159 }
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 (arg1)->SetPosition((wxPoint const &)*arg2);
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_Py_Void();
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26174 PyObject *obj;
26175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26176 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26177 return SWIG_Py_Void();
26178 }
26179
26180 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 return SWIG_Python_InitShadowInstance(args);
26182 }
26183
26184 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26185 PyObject *resultobj = 0;
26186 wxIdleEvent *result = 0 ;
26187
26188 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 result = (wxIdleEvent *)new wxIdleEvent();
26192 wxPyEndAllowThreads(__tstate);
26193 if (PyErr_Occurred()) SWIG_fail;
26194 }
26195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26196 return resultobj;
26197 fail:
26198 return NULL;
26199 }
26200
26201
26202 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26203 PyObject *resultobj = 0;
26204 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26205 bool arg2 = (bool) true ;
26206 void *argp1 = 0 ;
26207 int res1 = 0 ;
26208 bool val2 ;
26209 int ecode2 = 0 ;
26210 PyObject * obj0 = 0 ;
26211 PyObject * obj1 = 0 ;
26212 char * kwnames[] = {
26213 (char *) "self",(char *) "needMore", NULL
26214 };
26215
26216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26218 if (!SWIG_IsOK(res1)) {
26219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26220 }
26221 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26222 if (obj1) {
26223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26224 if (!SWIG_IsOK(ecode2)) {
26225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26226 }
26227 arg2 = static_cast< bool >(val2);
26228 }
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 (arg1)->RequestMore(arg2);
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_Py_Void();
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *resultobj = 0;
26244 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26245 bool result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject *swig_obj[1] ;
26249
26250 if (!args) SWIG_fail;
26251 swig_obj[0] = args;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26255 }
26256 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 {
26264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26265 }
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26273 PyObject *resultobj = 0;
26274 wxIdleMode arg1 ;
26275 int val1 ;
26276 int ecode1 = 0 ;
26277 PyObject * obj0 = 0 ;
26278 char * kwnames[] = {
26279 (char *) "mode", NULL
26280 };
26281
26282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26283 ecode1 = SWIG_AsVal_int(obj0, &val1);
26284 if (!SWIG_IsOK(ecode1)) {
26285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26286 }
26287 arg1 = static_cast< wxIdleMode >(val1);
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 wxIdleEvent::SetMode(arg1);
26291 wxPyEndAllowThreads(__tstate);
26292 if (PyErr_Occurred()) SWIG_fail;
26293 }
26294 resultobj = SWIG_Py_Void();
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *resultobj = 0;
26303 wxIdleMode result;
26304
26305 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (wxIdleMode)wxIdleEvent::GetMode();
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_From_int(static_cast< int >(result));
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxWindow *arg1 = (wxWindow *) 0 ;
26322 bool result;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 PyObject * obj0 = 0 ;
26326 char * kwnames[] = {
26327 (char *) "win", NULL
26328 };
26329
26330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26332 if (!SWIG_IsOK(res1)) {
26333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26334 }
26335 arg1 = reinterpret_cast< wxWindow * >(argp1);
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = (bool)wxIdleEvent::CanSend(arg1);
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26344 }
26345 return resultobj;
26346 fail:
26347 return NULL;
26348 }
26349
26350
26351 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26352 PyObject *obj;
26353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26354 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26355 return SWIG_Py_Void();
26356 }
26357
26358 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26359 return SWIG_Python_InitShadowInstance(args);
26360 }
26361
26362 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj = 0;
26364 int arg1 = (int) 0 ;
26365 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26366 wxPyEvent *result = 0 ;
26367 int val1 ;
26368 int ecode1 = 0 ;
26369 int val2 ;
26370 int ecode2 = 0 ;
26371 PyObject * obj0 = 0 ;
26372 PyObject * obj1 = 0 ;
26373 char * kwnames[] = {
26374 (char *) "winid",(char *) "eventType", NULL
26375 };
26376
26377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26378 if (obj0) {
26379 ecode1 = SWIG_AsVal_int(obj0, &val1);
26380 if (!SWIG_IsOK(ecode1)) {
26381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26382 }
26383 arg1 = static_cast< int >(val1);
26384 }
26385 if (obj1) {
26386 ecode2 = SWIG_AsVal_int(obj1, &val2);
26387 if (!SWIG_IsOK(ecode2)) {
26388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26389 }
26390 arg2 = static_cast< wxEventType >(val2);
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26408 void *argp1 = 0 ;
26409 int res1 = 0 ;
26410 PyObject *swig_obj[1] ;
26411
26412 if (!args) SWIG_fail;
26413 swig_obj[0] = args;
26414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26415 if (!SWIG_IsOK(res1)) {
26416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26417 }
26418 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 delete arg1;
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 resultobj = SWIG_Py_Void();
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26436 PyObject *arg2 = (PyObject *) 0 ;
26437 void *argp1 = 0 ;
26438 int res1 = 0 ;
26439 PyObject * obj0 = 0 ;
26440 PyObject * obj1 = 0 ;
26441 char * kwnames[] = {
26442 (char *) "self",(char *) "self", NULL
26443 };
26444
26445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26447 if (!SWIG_IsOK(res1)) {
26448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26449 }
26450 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26451 arg2 = obj1;
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 (arg1)->SetSelf(arg2);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_Py_Void();
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *resultobj = 0;
26467 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26468 PyObject *result = 0 ;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 PyObject *swig_obj[1] ;
26472
26473 if (!args) SWIG_fail;
26474 swig_obj[0] = args;
26475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26476 if (!SWIG_IsOK(res1)) {
26477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26478 }
26479 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = (PyObject *)(arg1)->GetSelf();
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 resultobj = result;
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26494 PyObject *obj;
26495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26497 return SWIG_Py_Void();
26498 }
26499
26500 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26501 return SWIG_Python_InitShadowInstance(args);
26502 }
26503
26504 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj = 0;
26506 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26507 int arg2 = (int) 0 ;
26508 wxPyCommandEvent *result = 0 ;
26509 int val1 ;
26510 int ecode1 = 0 ;
26511 int val2 ;
26512 int ecode2 = 0 ;
26513 PyObject * obj0 = 0 ;
26514 PyObject * obj1 = 0 ;
26515 char * kwnames[] = {
26516 (char *) "eventType",(char *) "id", NULL
26517 };
26518
26519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26520 if (obj0) {
26521 ecode1 = SWIG_AsVal_int(obj0, &val1);
26522 if (!SWIG_IsOK(ecode1)) {
26523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26524 }
26525 arg1 = static_cast< wxEventType >(val1);
26526 }
26527 if (obj1) {
26528 ecode2 = SWIG_AsVal_int(obj1, &val2);
26529 if (!SWIG_IsOK(ecode2)) {
26530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26531 }
26532 arg2 = static_cast< int >(val2);
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26550 void *argp1 = 0 ;
26551 int res1 = 0 ;
26552 PyObject *swig_obj[1] ;
26553
26554 if (!args) SWIG_fail;
26555 swig_obj[0] = args;
26556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26557 if (!SWIG_IsOK(res1)) {
26558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26559 }
26560 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 delete arg1;
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_Py_Void();
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26578 PyObject *arg2 = (PyObject *) 0 ;
26579 void *argp1 = 0 ;
26580 int res1 = 0 ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 char * kwnames[] = {
26584 (char *) "self",(char *) "self", NULL
26585 };
26586
26587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26591 }
26592 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26593 arg2 = obj1;
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 (arg1)->SetSelf(arg2);
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_Py_Void();
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26608 PyObject *resultobj = 0;
26609 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26610 PyObject *result = 0 ;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 PyObject *swig_obj[1] ;
26614
26615 if (!args) SWIG_fail;
26616 swig_obj[0] = args;
26617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26620 }
26621 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 result = (PyObject *)(arg1)->GetSelf();
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = result;
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26636 PyObject *obj;
26637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26638 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26639 return SWIG_Py_Void();
26640 }
26641
26642 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26643 return SWIG_Python_InitShadowInstance(args);
26644 }
26645
26646 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxWindow *arg1 = (wxWindow *) 0 ;
26649 wxDateTime *arg2 = 0 ;
26650 wxEventType arg3 ;
26651 wxDateEvent *result = 0 ;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 void *argp2 = 0 ;
26655 int res2 = 0 ;
26656 int val3 ;
26657 int ecode3 = 0 ;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 PyObject * obj2 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "win",(char *) "dt",(char *) "type", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26669 }
26670 arg1 = reinterpret_cast< wxWindow * >(argp1);
26671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26672 if (!SWIG_IsOK(res2)) {
26673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26674 }
26675 if (!argp2) {
26676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26677 }
26678 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26679 ecode3 = SWIG_AsVal_int(obj2, &val3);
26680 if (!SWIG_IsOK(ecode3)) {
26681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26682 }
26683 arg3 = static_cast< wxEventType >(val3);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26698 PyObject *resultobj = 0;
26699 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26700 wxDateTime *result = 0 ;
26701 void *argp1 = 0 ;
26702 int res1 = 0 ;
26703 PyObject *swig_obj[1] ;
26704
26705 if (!args) SWIG_fail;
26706 swig_obj[0] = args;
26707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26708 if (!SWIG_IsOK(res1)) {
26709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26710 }
26711 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26712 {
26713 PyThreadState* __tstate = wxPyBeginAllowThreads();
26714 {
26715 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26716 result = (wxDateTime *) &_result_ref;
26717 }
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26729 PyObject *resultobj = 0;
26730 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26731 wxDateTime *arg2 = 0 ;
26732 void *argp1 = 0 ;
26733 int res1 = 0 ;
26734 void *argp2 = 0 ;
26735 int res2 = 0 ;
26736 PyObject * obj0 = 0 ;
26737 PyObject * obj1 = 0 ;
26738 char * kwnames[] = {
26739 (char *) "self",(char *) "date", NULL
26740 };
26741
26742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26744 if (!SWIG_IsOK(res1)) {
26745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26746 }
26747 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26749 if (!SWIG_IsOK(res2)) {
26750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26751 }
26752 if (!argp2) {
26753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26754 }
26755 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetDate((wxDateTime const &)*arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *obj;
26771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26772 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26773 return SWIG_Py_Void();
26774 }
26775
26776 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 return SWIG_Python_InitShadowInstance(args);
26778 }
26779
26780 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26781 PyObject *resultobj = 0;
26782 wxPyApp *result = 0 ;
26783
26784 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxPyApp *)new_wxPyApp();
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *resultobj = 0;
26800 wxPyApp *arg1 = (wxPyApp *) 0 ;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 PyObject *swig_obj[1] ;
26804
26805 if (!args) SWIG_fail;
26806 swig_obj[0] = args;
26807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26808 if (!SWIG_IsOK(res1)) {
26809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26810 }
26811 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 delete arg1;
26815
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 resultobj = SWIG_Py_Void();
26820 return resultobj;
26821 fail:
26822 return NULL;
26823 }
26824
26825
26826 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26827 PyObject *resultobj = 0;
26828 wxPyApp *arg1 = (wxPyApp *) 0 ;
26829 PyObject *arg2 = (PyObject *) 0 ;
26830 PyObject *arg3 = (PyObject *) 0 ;
26831 bool arg4 ;
26832 void *argp1 = 0 ;
26833 int res1 = 0 ;
26834 bool val4 ;
26835 int ecode4 = 0 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 PyObject * obj3 = 0 ;
26840 char * kwnames[] = {
26841 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26842 };
26843
26844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26846 if (!SWIG_IsOK(res1)) {
26847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26848 }
26849 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26850 arg2 = obj1;
26851 arg3 = obj2;
26852 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26853 if (!SWIG_IsOK(ecode4)) {
26854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26855 }
26856 arg4 = static_cast< bool >(val4);
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 resultobj = SWIG_Py_Void();
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26871 PyObject *resultobj = 0;
26872 wxPyApp *arg1 = (wxPyApp *) 0 ;
26873 wxString result;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 PyObject *swig_obj[1] ;
26877
26878 if (!args) SWIG_fail;
26879 swig_obj[0] = args;
26880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26883 }
26884 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = ((wxPyApp const *)arg1)->GetAppName();
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 {
26892 #if wxUSE_UNICODE
26893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26894 #else
26895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26896 #endif
26897 }
26898 return resultobj;
26899 fail:
26900 return NULL;
26901 }
26902
26903
26904 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26905 PyObject *resultobj = 0;
26906 wxPyApp *arg1 = (wxPyApp *) 0 ;
26907 wxString *arg2 = 0 ;
26908 void *argp1 = 0 ;
26909 int res1 = 0 ;
26910 bool temp2 = false ;
26911 PyObject * obj0 = 0 ;
26912 PyObject * obj1 = 0 ;
26913 char * kwnames[] = {
26914 (char *) "self",(char *) "name", NULL
26915 };
26916
26917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26921 }
26922 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26923 {
26924 arg2 = wxString_in_helper(obj1);
26925 if (arg2 == NULL) SWIG_fail;
26926 temp2 = true;
26927 }
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 (arg1)->SetAppName((wxString const &)*arg2);
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_Py_Void();
26935 {
26936 if (temp2)
26937 delete arg2;
26938 }
26939 return resultobj;
26940 fail:
26941 {
26942 if (temp2)
26943 delete arg2;
26944 }
26945 return NULL;
26946 }
26947
26948
26949 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26950 PyObject *resultobj = 0;
26951 wxPyApp *arg1 = (wxPyApp *) 0 ;
26952 wxString result;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 PyObject *swig_obj[1] ;
26956
26957 if (!args) SWIG_fail;
26958 swig_obj[0] = args;
26959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26960 if (!SWIG_IsOK(res1)) {
26961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26962 }
26963 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = ((wxPyApp const *)arg1)->GetClassName();
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 {
26971 #if wxUSE_UNICODE
26972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26973 #else
26974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26975 #endif
26976 }
26977 return resultobj;
26978 fail:
26979 return NULL;
26980 }
26981
26982
26983 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj = 0;
26985 wxPyApp *arg1 = (wxPyApp *) 0 ;
26986 wxString *arg2 = 0 ;
26987 void *argp1 = 0 ;
26988 int res1 = 0 ;
26989 bool temp2 = false ;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 char * kwnames[] = {
26993 (char *) "self",(char *) "name", NULL
26994 };
26995
26996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26998 if (!SWIG_IsOK(res1)) {
26999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27000 }
27001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27002 {
27003 arg2 = wxString_in_helper(obj1);
27004 if (arg2 == NULL) SWIG_fail;
27005 temp2 = true;
27006 }
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 (arg1)->SetClassName((wxString const &)*arg2);
27010 wxPyEndAllowThreads(__tstate);
27011 if (PyErr_Occurred()) SWIG_fail;
27012 }
27013 resultobj = SWIG_Py_Void();
27014 {
27015 if (temp2)
27016 delete arg2;
27017 }
27018 return resultobj;
27019 fail:
27020 {
27021 if (temp2)
27022 delete arg2;
27023 }
27024 return NULL;
27025 }
27026
27027
27028 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 PyObject *resultobj = 0;
27030 wxPyApp *arg1 = (wxPyApp *) 0 ;
27031 wxString *result = 0 ;
27032 void *argp1 = 0 ;
27033 int res1 = 0 ;
27034 PyObject *swig_obj[1] ;
27035
27036 if (!args) SWIG_fail;
27037 swig_obj[0] = args;
27038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27039 if (!SWIG_IsOK(res1)) {
27040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27041 }
27042 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 {
27046 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27047 result = (wxString *) &_result_ref;
27048 }
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 {
27053 #if wxUSE_UNICODE
27054 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27055 #else
27056 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27057 #endif
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj = 0;
27067 wxPyApp *arg1 = (wxPyApp *) 0 ;
27068 wxString *arg2 = 0 ;
27069 void *argp1 = 0 ;
27070 int res1 = 0 ;
27071 bool temp2 = false ;
27072 PyObject * obj0 = 0 ;
27073 PyObject * obj1 = 0 ;
27074 char * kwnames[] = {
27075 (char *) "self",(char *) "name", NULL
27076 };
27077
27078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27080 if (!SWIG_IsOK(res1)) {
27081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27082 }
27083 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27084 {
27085 arg2 = wxString_in_helper(obj1);
27086 if (arg2 == NULL) SWIG_fail;
27087 temp2 = true;
27088 }
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 (arg1)->SetVendorName((wxString const &)*arg2);
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 resultobj = SWIG_Py_Void();
27096 {
27097 if (temp2)
27098 delete arg2;
27099 }
27100 return resultobj;
27101 fail:
27102 {
27103 if (temp2)
27104 delete arg2;
27105 }
27106 return NULL;
27107 }
27108
27109
27110 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27111 PyObject *resultobj = 0;
27112 wxPyApp *arg1 = (wxPyApp *) 0 ;
27113 wxAppTraits *result = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 PyObject *swig_obj[1] ;
27117
27118 if (!args) SWIG_fail;
27119 swig_obj[0] = args;
27120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27121 if (!SWIG_IsOK(res1)) {
27122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27123 }
27124 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = (wxAppTraits *)(arg1)->GetTraits();
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27139 PyObject *resultobj = 0;
27140 wxPyApp *arg1 = (wxPyApp *) 0 ;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 PyObject *swig_obj[1] ;
27144
27145 if (!args) SWIG_fail;
27146 swig_obj[0] = args;
27147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27148 if (!SWIG_IsOK(res1)) {
27149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27150 }
27151 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 (arg1)->ProcessPendingEvents();
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = SWIG_Py_Void();
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27166 PyObject *resultobj = 0;
27167 wxPyApp *arg1 = (wxPyApp *) 0 ;
27168 bool arg2 = (bool) false ;
27169 bool result;
27170 void *argp1 = 0 ;
27171 int res1 = 0 ;
27172 bool val2 ;
27173 int ecode2 = 0 ;
27174 PyObject * obj0 = 0 ;
27175 PyObject * obj1 = 0 ;
27176 char * kwnames[] = {
27177 (char *) "self",(char *) "onlyIfNeeded", NULL
27178 };
27179
27180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27182 if (!SWIG_IsOK(res1)) {
27183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27184 }
27185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27186 if (obj1) {
27187 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27188 if (!SWIG_IsOK(ecode2)) {
27189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27190 }
27191 arg2 = static_cast< bool >(val2);
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (bool)(arg1)->Yield(arg2);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27209 PyObject *resultobj = 0;
27210 wxPyApp *arg1 = (wxPyApp *) 0 ;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 PyObject *swig_obj[1] ;
27214
27215 if (!args) SWIG_fail;
27216 swig_obj[0] = args;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27220 }
27221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->WakeUpIdle();
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 resultobj = SWIG_Py_Void();
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27236 PyObject *resultobj = 0;
27237 bool result;
27238
27239 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)wxPyApp::IsMainLoopRunning();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27256 PyObject *resultobj = 0;
27257 wxPyApp *arg1 = (wxPyApp *) 0 ;
27258 int result;
27259 void *argp1 = 0 ;
27260 int res1 = 0 ;
27261 PyObject *swig_obj[1] ;
27262
27263 if (!args) SWIG_fail;
27264 swig_obj[0] = args;
27265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27266 if (!SWIG_IsOK(res1)) {
27267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27268 }
27269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (int)(arg1)->MainLoop();
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_From_int(static_cast< int >(result));
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27284 PyObject *resultobj = 0;
27285 wxPyApp *arg1 = (wxPyApp *) 0 ;
27286 void *argp1 = 0 ;
27287 int res1 = 0 ;
27288 PyObject *swig_obj[1] ;
27289
27290 if (!args) SWIG_fail;
27291 swig_obj[0] = args;
27292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27295 }
27296 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 (arg1)->Exit();
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 resultobj = SWIG_Py_Void();
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27311 PyObject *resultobj = 0;
27312 wxPyApp *arg1 = (wxPyApp *) 0 ;
27313 void *argp1 = 0 ;
27314 int res1 = 0 ;
27315 PyObject *swig_obj[1] ;
27316
27317 if (!args) SWIG_fail;
27318 swig_obj[0] = args;
27319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27320 if (!SWIG_IsOK(res1)) {
27321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27322 }
27323 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27324 {
27325 PyThreadState* __tstate = wxPyBeginAllowThreads();
27326 (arg1)->ExitMainLoop();
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 resultobj = SWIG_Py_Void();
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27338 PyObject *resultobj = 0;
27339 wxPyApp *arg1 = (wxPyApp *) 0 ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 PyObject *swig_obj[1] ;
27344
27345 if (!args) SWIG_fail;
27346 swig_obj[0] = args;
27347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27348 if (!SWIG_IsOK(res1)) {
27349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27350 }
27351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (bool)(arg1)->Pending();
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 bool result;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 PyObject *swig_obj[1] ;
27374
27375 if (!args) SWIG_fail;
27376 swig_obj[0] = args;
27377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27378 if (!SWIG_IsOK(res1)) {
27379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27380 }
27381 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = (bool)(arg1)->Dispatch();
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 {
27389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27390 }
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27398 PyObject *resultobj = 0;
27399 wxPyApp *arg1 = (wxPyApp *) 0 ;
27400 bool result;
27401 void *argp1 = 0 ;
27402 int res1 = 0 ;
27403 PyObject *swig_obj[1] ;
27404
27405 if (!args) SWIG_fail;
27406 swig_obj[0] = args;
27407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27408 if (!SWIG_IsOK(res1)) {
27409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27410 }
27411 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 result = (bool)(arg1)->ProcessIdle();
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 {
27419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27420 }
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj = 0;
27429 wxPyApp *arg1 = (wxPyApp *) 0 ;
27430 wxWindow *arg2 = (wxWindow *) 0 ;
27431 wxIdleEvent *arg3 = 0 ;
27432 bool result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 void *argp2 = 0 ;
27436 int res2 = 0 ;
27437 void *argp3 = 0 ;
27438 int res3 = 0 ;
27439 PyObject * obj0 = 0 ;
27440 PyObject * obj1 = 0 ;
27441 PyObject * obj2 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "win",(char *) "event", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27453 if (!SWIG_IsOK(res2)) {
27454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27455 }
27456 arg2 = reinterpret_cast< wxWindow * >(argp2);
27457 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27458 if (!SWIG_IsOK(res3)) {
27459 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27460 }
27461 if (!argp3) {
27462 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27463 }
27464 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 {
27472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27473 }
27474 return resultobj;
27475 fail:
27476 return NULL;
27477 }
27478
27479
27480 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27481 PyObject *resultobj = 0;
27482 wxPyApp *arg1 = (wxPyApp *) 0 ;
27483 bool result;
27484 void *argp1 = 0 ;
27485 int res1 = 0 ;
27486 PyObject *swig_obj[1] ;
27487
27488 if (!args) SWIG_fail;
27489 swig_obj[0] = args;
27490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27491 if (!SWIG_IsOK(res1)) {
27492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27493 }
27494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 result = (bool)((wxPyApp const *)arg1)->IsActive();
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 {
27502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27503 }
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27511 PyObject *resultobj = 0;
27512 wxPyApp *arg1 = (wxPyApp *) 0 ;
27513 wxWindow *arg2 = (wxWindow *) 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 void *argp2 = 0 ;
27517 int res2 = 0 ;
27518 PyObject * obj0 = 0 ;
27519 PyObject * obj1 = 0 ;
27520 char * kwnames[] = {
27521 (char *) "self",(char *) "win", NULL
27522 };
27523
27524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27526 if (!SWIG_IsOK(res1)) {
27527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27528 }
27529 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27531 if (!SWIG_IsOK(res2)) {
27532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27533 }
27534 arg2 = reinterpret_cast< wxWindow * >(argp2);
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 (arg1)->SetTopWindow(arg2);
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_Py_Void();
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 PyObject *resultobj = 0;
27550 wxPyApp *arg1 = (wxPyApp *) 0 ;
27551 wxWindow *result = 0 ;
27552 void *argp1 = 0 ;
27553 int res1 = 0 ;
27554 PyObject *swig_obj[1] ;
27555
27556 if (!args) SWIG_fail;
27557 swig_obj[0] = args;
27558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27559 if (!SWIG_IsOK(res1)) {
27560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27561 }
27562 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 {
27570 resultobj = wxPyMake_wxObject(result, (bool)0);
27571 }
27572 return resultobj;
27573 fail:
27574 return NULL;
27575 }
27576
27577
27578 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj = 0;
27580 wxPyApp *arg1 = (wxPyApp *) 0 ;
27581 bool arg2 ;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 bool val2 ;
27585 int ecode2 = 0 ;
27586 PyObject * obj0 = 0 ;
27587 PyObject * obj1 = 0 ;
27588 char * kwnames[] = {
27589 (char *) "self",(char *) "flag", NULL
27590 };
27591
27592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27596 }
27597 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27599 if (!SWIG_IsOK(ecode2)) {
27600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27601 }
27602 arg2 = static_cast< bool >(val2);
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 (arg1)->SetExitOnFrameDelete(arg2);
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 resultobj = SWIG_Py_Void();
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27617 PyObject *resultobj = 0;
27618 wxPyApp *arg1 = (wxPyApp *) 0 ;
27619 bool result;
27620 void *argp1 = 0 ;
27621 int res1 = 0 ;
27622 PyObject *swig_obj[1] ;
27623
27624 if (!args) SWIG_fail;
27625 swig_obj[0] = args;
27626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27627 if (!SWIG_IsOK(res1)) {
27628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27629 }
27630 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 {
27638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27639 }
27640 return resultobj;
27641 fail:
27642 return NULL;
27643 }
27644
27645
27646 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 wxPyApp *arg1 = (wxPyApp *) 0 ;
27649 bool arg2 ;
27650 void *argp1 = 0 ;
27651 int res1 = 0 ;
27652 bool val2 ;
27653 int ecode2 = 0 ;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char * kwnames[] = {
27657 (char *) "self",(char *) "flag", NULL
27658 };
27659
27660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27664 }
27665 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27667 if (!SWIG_IsOK(ecode2)) {
27668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27669 }
27670 arg2 = static_cast< bool >(val2);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 (arg1)->SetUseBestVisual(arg2);
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = SWIG_Py_Void();
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27685 PyObject *resultobj = 0;
27686 wxPyApp *arg1 = (wxPyApp *) 0 ;
27687 bool result;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 PyObject *swig_obj[1] ;
27691
27692 if (!args) SWIG_fail;
27693 swig_obj[0] = args;
27694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27695 if (!SWIG_IsOK(res1)) {
27696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27697 }
27698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27699 {
27700 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 {
27706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27707 }
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj = 0;
27716 wxPyApp *arg1 = (wxPyApp *) 0 ;
27717 int arg2 ;
27718 void *argp1 = 0 ;
27719 int res1 = 0 ;
27720 int val2 ;
27721 int ecode2 = 0 ;
27722 PyObject * obj0 = 0 ;
27723 PyObject * obj1 = 0 ;
27724 char * kwnames[] = {
27725 (char *) "self",(char *) "mode", NULL
27726 };
27727
27728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27730 if (!SWIG_IsOK(res1)) {
27731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27732 }
27733 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27734 ecode2 = SWIG_AsVal_int(obj1, &val2);
27735 if (!SWIG_IsOK(ecode2)) {
27736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27737 }
27738 arg2 = static_cast< int >(val2);
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 (arg1)->SetPrintMode(arg2);
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 resultobj = SWIG_Py_Void();
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxPyApp *arg1 = (wxPyApp *) 0 ;
27755 int result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27765 }
27766 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 resultobj = SWIG_From_int(static_cast< int >(result));
27774 return resultobj;
27775 fail:
27776 return NULL;
27777 }
27778
27779
27780 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27781 PyObject *resultobj = 0;
27782 wxPyApp *arg1 = (wxPyApp *) 0 ;
27783 int arg2 ;
27784 void *argp1 = 0 ;
27785 int res1 = 0 ;
27786 int val2 ;
27787 int ecode2 = 0 ;
27788 PyObject * obj0 = 0 ;
27789 PyObject * obj1 = 0 ;
27790 char * kwnames[] = {
27791 (char *) "self",(char *) "mode", NULL
27792 };
27793
27794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27796 if (!SWIG_IsOK(res1)) {
27797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27798 }
27799 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27800 ecode2 = SWIG_AsVal_int(obj1, &val2);
27801 if (!SWIG_IsOK(ecode2)) {
27802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27803 }
27804 arg2 = static_cast< int >(val2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 (arg1)->SetAssertMode(arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_Py_Void();
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27819 PyObject *resultobj = 0;
27820 wxPyApp *arg1 = (wxPyApp *) 0 ;
27821 int result;
27822 void *argp1 = 0 ;
27823 int res1 = 0 ;
27824 PyObject *swig_obj[1] ;
27825
27826 if (!args) SWIG_fail;
27827 swig_obj[0] = args;
27828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27829 if (!SWIG_IsOK(res1)) {
27830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27831 }
27832 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (int)(arg1)->GetAssertMode();
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 resultobj = SWIG_From_int(static_cast< int >(result));
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 bool result;
27849
27850 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 {
27858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27859 }
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 long result;
27869
27870 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 result = (long)wxPyApp::GetMacAboutMenuItemId();
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 resultobj = SWIG_From_long(static_cast< long >(result));
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27885 PyObject *resultobj = 0;
27886 long result;
27887
27888 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 resultobj = SWIG_From_long(static_cast< long >(result));
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 long result;
27905
27906 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (long)wxPyApp::GetMacExitMenuItemId();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 resultobj = SWIG_From_long(static_cast< long >(result));
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27921 PyObject *resultobj = 0;
27922 wxString result;
27923
27924 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = wxPyApp::GetMacHelpMenuTitleName();
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 #if wxUSE_UNICODE
27933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27934 #else
27935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27936 #endif
27937 }
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 bool arg1 ;
27947 bool val1 ;
27948 int ecode1 = 0 ;
27949 PyObject * obj0 = 0 ;
27950 char * kwnames[] = {
27951 (char *) "val", NULL
27952 };
27953
27954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27955 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27956 if (!SWIG_IsOK(ecode1)) {
27957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27958 }
27959 arg1 = static_cast< bool >(val1);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
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_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27974 PyObject *resultobj = 0;
27975 long arg1 ;
27976 long val1 ;
27977 int ecode1 = 0 ;
27978 PyObject * obj0 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "val", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27984 ecode1 = SWIG_AsVal_long(obj0, &val1);
27985 if (!SWIG_IsOK(ecode1)) {
27986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27987 }
27988 arg1 = static_cast< long >(val1);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 wxPyApp::SetMacAboutMenuItemId(arg1);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_Py_Void();
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj = 0;
28004 long arg1 ;
28005 long val1 ;
28006 int ecode1 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "val", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28013 ecode1 = SWIG_AsVal_long(obj0, &val1);
28014 if (!SWIG_IsOK(ecode1)) {
28015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28016 }
28017 arg1 = static_cast< long >(val1);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_Py_Void();
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 long arg1 ;
28034 long val1 ;
28035 int ecode1 = 0 ;
28036 PyObject * obj0 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "val", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28042 ecode1 = SWIG_AsVal_long(obj0, &val1);
28043 if (!SWIG_IsOK(ecode1)) {
28044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28045 }
28046 arg1 = static_cast< long >(val1);
28047 {
28048 PyThreadState* __tstate = wxPyBeginAllowThreads();
28049 wxPyApp::SetMacExitMenuItemId(arg1);
28050 wxPyEndAllowThreads(__tstate);
28051 if (PyErr_Occurred()) SWIG_fail;
28052 }
28053 resultobj = SWIG_Py_Void();
28054 return resultobj;
28055 fail:
28056 return NULL;
28057 }
28058
28059
28060 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj = 0;
28062 wxString *arg1 = 0 ;
28063 bool temp1 = false ;
28064 PyObject * obj0 = 0 ;
28065 char * kwnames[] = {
28066 (char *) "val", NULL
28067 };
28068
28069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28070 {
28071 arg1 = wxString_in_helper(obj0);
28072 if (arg1 == NULL) SWIG_fail;
28073 temp1 = true;
28074 }
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 resultobj = SWIG_Py_Void();
28082 {
28083 if (temp1)
28084 delete arg1;
28085 }
28086 return resultobj;
28087 fail:
28088 {
28089 if (temp1)
28090 delete arg1;
28091 }
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28097 PyObject *resultobj = 0;
28098 wxPyApp *arg1 = (wxPyApp *) 0 ;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 PyObject *swig_obj[1] ;
28102
28103 if (!args) SWIG_fail;
28104 swig_obj[0] = args;
28105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28106 if (!SWIG_IsOK(res1)) {
28107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28108 }
28109 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 (arg1)->_BootstrapApp();
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_Py_Void();
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28124 PyObject *resultobj = 0;
28125 int result;
28126
28127 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (int)wxPyApp::GetComCtl32Version();
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_From_int(static_cast< int >(result));
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28142 PyObject *obj;
28143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28144 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28145 return SWIG_Py_Void();
28146 }
28147
28148 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28149 return SWIG_Python_InitShadowInstance(args);
28150 }
28151
28152 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28153 PyObject *resultobj = 0;
28154
28155 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 wxExit();
28159 wxPyEndAllowThreads(__tstate);
28160 if (PyErr_Occurred()) SWIG_fail;
28161 }
28162 resultobj = SWIG_Py_Void();
28163 return resultobj;
28164 fail:
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171 bool result;
28172
28173 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (bool)wxYield();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28190 PyObject *resultobj = 0;
28191 bool result;
28192
28193 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (bool)wxYieldIfNeeded();
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 {
28201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = 0;
28211 wxWindow *arg1 = (wxWindow *) NULL ;
28212 bool arg2 = (bool) false ;
28213 bool result;
28214 void *argp1 = 0 ;
28215 int res1 = 0 ;
28216 bool val2 ;
28217 int ecode2 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char * kwnames[] = {
28221 (char *) "win",(char *) "onlyIfNeeded", NULL
28222 };
28223
28224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28225 if (obj0) {
28226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28227 if (!SWIG_IsOK(res1)) {
28228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28229 }
28230 arg1 = reinterpret_cast< wxWindow * >(argp1);
28231 }
28232 if (obj1) {
28233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28234 if (!SWIG_IsOK(ecode2)) {
28235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28236 }
28237 arg2 = static_cast< bool >(val2);
28238 }
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (bool)wxSafeYield(arg1,arg2);
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28255 PyObject *resultobj = 0;
28256
28257 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 wxWakeUpIdle();
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 resultobj = SWIG_Py_Void();
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj = 0;
28273 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28274 wxEvent *arg2 = 0 ;
28275 void *argp1 = 0 ;
28276 int res1 = 0 ;
28277 void *argp2 = 0 ;
28278 int res2 = 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "dest",(char *) "event", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28289 }
28290 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28292 if (!SWIG_IsOK(res2)) {
28293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28294 }
28295 if (!argp2) {
28296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28297 }
28298 arg2 = reinterpret_cast< wxEvent * >(argp2);
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 wxPostEvent(arg1,*arg2);
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = SWIG_Py_Void();
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28313 PyObject *resultobj = 0;
28314
28315 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 wxApp_CleanUp();
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_Py_Void();
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 PyObject *resultobj = 0;
28331 wxPyApp *result = 0 ;
28332
28333 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (wxPyApp *)wxPyGetApp();
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 {
28341 resultobj = wxPyMake_wxObject(result, 0);
28342 }
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28350 PyObject *resultobj = 0;
28351 char *arg1 = (char *) 0 ;
28352 int res1 ;
28353 char *buf1 = 0 ;
28354 int alloc1 = 0 ;
28355 PyObject * obj0 = 0 ;
28356 char * kwnames[] = {
28357 (char *) "encoding", NULL
28358 };
28359
28360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28361 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28362 if (!SWIG_IsOK(res1)) {
28363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28364 }
28365 arg1 = buf1;
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 wxSetDefaultPyEncoding((char const *)arg1);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_Py_Void();
28373 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28374 return resultobj;
28375 fail:
28376 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28377 return NULL;
28378 }
28379
28380
28381 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28382 PyObject *resultobj = 0;
28383 char *result = 0 ;
28384
28385 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = (char *)wxGetDefaultPyEncoding();
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_FromCharPtr(result);
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28400 PyObject *resultobj = 0;
28401 wxEventLoop *result = 0 ;
28402
28403 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (wxEventLoop *)new wxEventLoop();
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28420 void *argp1 = 0 ;
28421 int res1 = 0 ;
28422 PyObject *swig_obj[1] ;
28423
28424 if (!args) SWIG_fail;
28425 swig_obj[0] = args;
28426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28427 if (!SWIG_IsOK(res1)) {
28428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28429 }
28430 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 delete arg1;
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 resultobj = SWIG_Py_Void();
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28446 PyObject *resultobj = 0;
28447 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28448 int result;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 PyObject *swig_obj[1] ;
28452
28453 if (!args) SWIG_fail;
28454 swig_obj[0] = args;
28455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28456 if (!SWIG_IsOK(res1)) {
28457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28458 }
28459 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (int)(arg1)->Run();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_From_int(static_cast< int >(result));
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj = 0;
28475 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28476 int arg2 = (int) 0 ;
28477 void *argp1 = 0 ;
28478 int res1 = 0 ;
28479 int val2 ;
28480 int ecode2 = 0 ;
28481 PyObject * obj0 = 0 ;
28482 PyObject * obj1 = 0 ;
28483 char * kwnames[] = {
28484 (char *) "self",(char *) "rc", NULL
28485 };
28486
28487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28489 if (!SWIG_IsOK(res1)) {
28490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28491 }
28492 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28493 if (obj1) {
28494 ecode2 = SWIG_AsVal_int(obj1, &val2);
28495 if (!SWIG_IsOK(ecode2)) {
28496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28497 }
28498 arg2 = static_cast< int >(val2);
28499 }
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 (arg1)->Exit(arg2);
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 resultobj = SWIG_Py_Void();
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28514 PyObject *resultobj = 0;
28515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28516 bool result;
28517 void *argp1 = 0 ;
28518 int res1 = 0 ;
28519 PyObject *swig_obj[1] ;
28520
28521 if (!args) SWIG_fail;
28522 swig_obj[0] = args;
28523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28526 }
28527 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (bool)((wxEventLoop const *)arg1)->Pending();
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 {
28535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *resultobj = 0;
28545 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28546 bool result;
28547 void *argp1 = 0 ;
28548 int res1 = 0 ;
28549 PyObject *swig_obj[1] ;
28550
28551 if (!args) SWIG_fail;
28552 swig_obj[0] = args;
28553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28554 if (!SWIG_IsOK(res1)) {
28555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28556 }
28557 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (bool)(arg1)->Dispatch();
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28566 }
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28576 bool result;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 PyObject *swig_obj[1] ;
28580
28581 if (!args) SWIG_fail;
28582 swig_obj[0] = args;
28583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28586 }
28587 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *resultobj = 0;
28605 wxEventLoop *result = 0 ;
28606
28607 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 result = (wxEventLoop *)wxEventLoop::GetActive();
28611 wxPyEndAllowThreads(__tstate);
28612 if (PyErr_Occurred()) SWIG_fail;
28613 }
28614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28615 return resultobj;
28616 fail:
28617 return NULL;
28618 }
28619
28620
28621 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28622 PyObject *resultobj = 0;
28623 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28624 void *argp1 = 0 ;
28625 int res1 = 0 ;
28626 PyObject * obj0 = 0 ;
28627 char * kwnames[] = {
28628 (char *) "loop", NULL
28629 };
28630
28631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28635 }
28636 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 wxEventLoop::SetActive(arg1);
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 resultobj = SWIG_Py_Void();
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28651 PyObject *obj;
28652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28653 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28654 return SWIG_Py_Void();
28655 }
28656
28657 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 return SWIG_Python_InitShadowInstance(args);
28659 }
28660
28661 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28664 wxEventLoopActivator *result = 0 ;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 char * kwnames[] = {
28669 (char *) "evtLoop", NULL
28670 };
28671
28672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28674 if (!SWIG_IsOK(res1)) {
28675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28676 }
28677 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28692 PyObject *resultobj = 0;
28693 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 PyObject *swig_obj[1] ;
28697
28698 if (!args) SWIG_fail;
28699 swig_obj[0] = args;
28700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28701 if (!SWIG_IsOK(res1)) {
28702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28703 }
28704 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 delete arg1;
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_Py_Void();
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *obj;
28721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28722 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28723 return SWIG_Py_Void();
28724 }
28725
28726 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28727 return SWIG_Python_InitShadowInstance(args);
28728 }
28729
28730 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj = 0;
28732 int arg1 = (int) 0 ;
28733 int arg2 = (int) 0 ;
28734 int arg3 = (int) 0 ;
28735 wxAcceleratorEntry *result = 0 ;
28736 int val1 ;
28737 int ecode1 = 0 ;
28738 int val2 ;
28739 int ecode2 = 0 ;
28740 int val3 ;
28741 int ecode3 = 0 ;
28742 PyObject * obj0 = 0 ;
28743 PyObject * obj1 = 0 ;
28744 PyObject * obj2 = 0 ;
28745 char * kwnames[] = {
28746 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28747 };
28748
28749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28750 if (obj0) {
28751 ecode1 = SWIG_AsVal_int(obj0, &val1);
28752 if (!SWIG_IsOK(ecode1)) {
28753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28754 }
28755 arg1 = static_cast< int >(val1);
28756 }
28757 if (obj1) {
28758 ecode2 = SWIG_AsVal_int(obj1, &val2);
28759 if (!SWIG_IsOK(ecode2)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28761 }
28762 arg2 = static_cast< int >(val2);
28763 }
28764 if (obj2) {
28765 ecode3 = SWIG_AsVal_int(obj2, &val3);
28766 if (!SWIG_IsOK(ecode3)) {
28767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28768 }
28769 arg3 = static_cast< int >(val3);
28770 }
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28774 wxPyEndAllowThreads(__tstate);
28775 if (PyErr_Occurred()) SWIG_fail;
28776 }
28777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28778 return resultobj;
28779 fail:
28780 return NULL;
28781 }
28782
28783
28784 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28785 PyObject *resultobj = 0;
28786 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28787 void *argp1 = 0 ;
28788 int res1 = 0 ;
28789 PyObject *swig_obj[1] ;
28790
28791 if (!args) SWIG_fail;
28792 swig_obj[0] = args;
28793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28794 if (!SWIG_IsOK(res1)) {
28795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28796 }
28797 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 delete arg1;
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_Py_Void();
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj = 0;
28814 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28815 int arg2 ;
28816 int arg3 ;
28817 int arg4 ;
28818 void *argp1 = 0 ;
28819 int res1 = 0 ;
28820 int val2 ;
28821 int ecode2 = 0 ;
28822 int val3 ;
28823 int ecode3 = 0 ;
28824 int val4 ;
28825 int ecode4 = 0 ;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 PyObject * obj2 = 0 ;
28829 PyObject * obj3 = 0 ;
28830 char * kwnames[] = {
28831 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28832 };
28833
28834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28838 }
28839 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28840 ecode2 = SWIG_AsVal_int(obj1, &val2);
28841 if (!SWIG_IsOK(ecode2)) {
28842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28843 }
28844 arg2 = static_cast< int >(val2);
28845 ecode3 = SWIG_AsVal_int(obj2, &val3);
28846 if (!SWIG_IsOK(ecode3)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28848 }
28849 arg3 = static_cast< int >(val3);
28850 ecode4 = SWIG_AsVal_int(obj3, &val4);
28851 if (!SWIG_IsOK(ecode4)) {
28852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28853 }
28854 arg4 = static_cast< int >(val4);
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 (arg1)->Set(arg2,arg3,arg4);
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 resultobj = SWIG_Py_Void();
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28869 PyObject *resultobj = 0;
28870 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28871 int result;
28872 void *argp1 = 0 ;
28873 int res1 = 0 ;
28874 PyObject *swig_obj[1] ;
28875
28876 if (!args) SWIG_fail;
28877 swig_obj[0] = args;
28878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28879 if (!SWIG_IsOK(res1)) {
28880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28881 }
28882 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 result = (int)(arg1)->GetFlags();
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 resultobj = SWIG_From_int(static_cast< int >(result));
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 PyObject *resultobj = 0;
28898 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28899 int result;
28900 void *argp1 = 0 ;
28901 int res1 = 0 ;
28902 PyObject *swig_obj[1] ;
28903
28904 if (!args) SWIG_fail;
28905 swig_obj[0] = args;
28906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28907 if (!SWIG_IsOK(res1)) {
28908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28909 }
28910 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 result = (int)(arg1)->GetKeyCode();
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 resultobj = SWIG_From_int(static_cast< int >(result));
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28925 PyObject *resultobj = 0;
28926 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28927 int result;
28928 void *argp1 = 0 ;
28929 int res1 = 0 ;
28930 PyObject *swig_obj[1] ;
28931
28932 if (!args) SWIG_fail;
28933 swig_obj[0] = args;
28934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28935 if (!SWIG_IsOK(res1)) {
28936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28937 }
28938 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28939 {
28940 PyThreadState* __tstate = wxPyBeginAllowThreads();
28941 result = (int)(arg1)->GetCommand();
28942 wxPyEndAllowThreads(__tstate);
28943 if (PyErr_Occurred()) SWIG_fail;
28944 }
28945 resultobj = SWIG_From_int(static_cast< int >(result));
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28953 PyObject *obj;
28954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28955 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28956 return SWIG_Py_Void();
28957 }
28958
28959 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 return SWIG_Python_InitShadowInstance(args);
28961 }
28962
28963 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj = 0;
28965 int arg1 ;
28966 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28967 wxAcceleratorTable *result = 0 ;
28968 PyObject * obj0 = 0 ;
28969 char * kwnames[] = {
28970 (char *) "n", NULL
28971 };
28972
28973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28974 {
28975 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28976 if (arg2) arg1 = PyList_Size(obj0);
28977 else arg1 = 0;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 PyObject *resultobj = 0;
28994 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28995 void *argp1 = 0 ;
28996 int res1 = 0 ;
28997 PyObject *swig_obj[1] ;
28998
28999 if (!args) SWIG_fail;
29000 swig_obj[0] = args;
29001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29002 if (!SWIG_IsOK(res1)) {
29003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29004 }
29005 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 delete arg1;
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 resultobj = SWIG_Py_Void();
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29021 PyObject *resultobj = 0;
29022 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29023 bool result;
29024 void *argp1 = 0 ;
29025 int res1 = 0 ;
29026 PyObject *swig_obj[1] ;
29027
29028 if (!args) SWIG_fail;
29029 swig_obj[0] = args;
29030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29031 if (!SWIG_IsOK(res1)) {
29032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29033 }
29034 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29035 {
29036 PyThreadState* __tstate = wxPyBeginAllowThreads();
29037 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 {
29042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29043 }
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *obj;
29052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29053 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29054 return SWIG_Py_Void();
29055 }
29056
29057 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 return SWIG_Python_InitShadowInstance(args);
29059 }
29060
29061 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29062 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29063 return 1;
29064 }
29065
29066
29067 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29068 PyObject *pyobj = 0;
29069
29070 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29071 return pyobj;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29076 PyObject *resultobj = 0;
29077 wxString *arg1 = 0 ;
29078 wxAcceleratorEntry *result = 0 ;
29079 bool temp1 = false ;
29080 PyObject * obj0 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "label", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29086 {
29087 arg1 = wxString_in_helper(obj0);
29088 if (arg1 == NULL) SWIG_fail;
29089 temp1 = true;
29090 }
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29098 {
29099 if (temp1)
29100 delete arg1;
29101 }
29102 return resultobj;
29103 fail:
29104 {
29105 if (temp1)
29106 delete arg1;
29107 }
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN int PanelNameStr_set(PyObject *) {
29113 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29114 return 1;
29115 }
29116
29117
29118 SWIGINTERN PyObject *PanelNameStr_get(void) {
29119 PyObject *pyobj = 0;
29120
29121 {
29122 #if wxUSE_UNICODE
29123 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29124 #else
29125 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29126 #endif
29127 }
29128 return pyobj;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29133 PyObject *resultobj = 0;
29134 wxVisualAttributes *result = 0 ;
29135
29136 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 result = (wxVisualAttributes *)new_wxVisualAttributes();
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 PyObject *resultobj = 0;
29152 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29153 void *argp1 = 0 ;
29154 int res1 = 0 ;
29155 PyObject *swig_obj[1] ;
29156
29157 if (!args) SWIG_fail;
29158 swig_obj[0] = args;
29159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29160 if (!SWIG_IsOK(res1)) {
29161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29162 }
29163 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 delete_wxVisualAttributes(arg1);
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_Py_Void();
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29179 PyObject *resultobj = 0;
29180 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29181 wxFont *arg2 = (wxFont *) 0 ;
29182 void *argp1 = 0 ;
29183 int res1 = 0 ;
29184 void *argp2 = 0 ;
29185 int res2 = 0 ;
29186 PyObject *swig_obj[2] ;
29187
29188 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29192 }
29193 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29194 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29195 if (!SWIG_IsOK(res2)) {
29196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29197 }
29198 arg2 = reinterpret_cast< wxFont * >(argp2);
29199 if (arg1) (arg1)->font = *arg2;
29200
29201 resultobj = SWIG_Py_Void();
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29209 PyObject *resultobj = 0;
29210 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29211 wxFont *result = 0 ;
29212 void *argp1 = 0 ;
29213 int res1 = 0 ;
29214 PyObject *swig_obj[1] ;
29215
29216 if (!args) SWIG_fail;
29217 swig_obj[0] = args;
29218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29221 }
29222 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29223 result = (wxFont *)& ((arg1)->font);
29224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *resultobj = 0;
29233 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29234 wxColour *arg2 = (wxColour *) 0 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 void *argp2 = 0 ;
29238 int res2 = 0 ;
29239 PyObject *swig_obj[2] ;
29240
29241 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29243 if (!SWIG_IsOK(res1)) {
29244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29245 }
29246 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29247 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29248 if (!SWIG_IsOK(res2)) {
29249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29250 }
29251 arg2 = reinterpret_cast< wxColour * >(argp2);
29252 if (arg1) (arg1)->colFg = *arg2;
29253
29254 resultobj = SWIG_Py_Void();
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29262 PyObject *resultobj = 0;
29263 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29264 wxColour *result = 0 ;
29265 void *argp1 = 0 ;
29266 int res1 = 0 ;
29267 PyObject *swig_obj[1] ;
29268
29269 if (!args) SWIG_fail;
29270 swig_obj[0] = args;
29271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29272 if (!SWIG_IsOK(res1)) {
29273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29274 }
29275 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29276 result = (wxColour *)& ((arg1)->colFg);
29277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29285 PyObject *resultobj = 0;
29286 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29287 wxColour *arg2 = (wxColour *) 0 ;
29288 void *argp1 = 0 ;
29289 int res1 = 0 ;
29290 void *argp2 = 0 ;
29291 int res2 = 0 ;
29292 PyObject *swig_obj[2] ;
29293
29294 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29298 }
29299 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29300 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29301 if (!SWIG_IsOK(res2)) {
29302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29303 }
29304 arg2 = reinterpret_cast< wxColour * >(argp2);
29305 if (arg1) (arg1)->colBg = *arg2;
29306
29307 resultobj = SWIG_Py_Void();
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29315 PyObject *resultobj = 0;
29316 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29317 wxColour *result = 0 ;
29318 void *argp1 = 0 ;
29319 int res1 = 0 ;
29320 PyObject *swig_obj[1] ;
29321
29322 if (!args) SWIG_fail;
29323 swig_obj[0] = args;
29324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29325 if (!SWIG_IsOK(res1)) {
29326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29327 }
29328 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29329 result = (wxColour *)& ((arg1)->colBg);
29330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *obj;
29339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29340 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29341 return SWIG_Py_Void();
29342 }
29343
29344 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29345 return SWIG_Python_InitShadowInstance(args);
29346 }
29347
29348 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29349 PyObject *resultobj = 0;
29350 wxWindow *arg1 = (wxWindow *) 0 ;
29351 int arg2 = (int) (int)-1 ;
29352 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29353 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29354 wxSize const &arg4_defvalue = wxDefaultSize ;
29355 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29356 long arg5 = (long) 0 ;
29357 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29358 wxString *arg6 = (wxString *) &arg6_defvalue ;
29359 wxWindow *result = 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 int val2 ;
29363 int ecode2 = 0 ;
29364 wxPoint temp3 ;
29365 wxSize temp4 ;
29366 long val5 ;
29367 int ecode5 = 0 ;
29368 bool temp6 = false ;
29369 PyObject * obj0 = 0 ;
29370 PyObject * obj1 = 0 ;
29371 PyObject * obj2 = 0 ;
29372 PyObject * obj3 = 0 ;
29373 PyObject * obj4 = 0 ;
29374 PyObject * obj5 = 0 ;
29375 char * kwnames[] = {
29376 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29377 };
29378
29379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29381 if (!SWIG_IsOK(res1)) {
29382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29383 }
29384 arg1 = reinterpret_cast< wxWindow * >(argp1);
29385 if (obj1) {
29386 ecode2 = SWIG_AsVal_int(obj1, &val2);
29387 if (!SWIG_IsOK(ecode2)) {
29388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29389 }
29390 arg2 = static_cast< int >(val2);
29391 }
29392 if (obj2) {
29393 {
29394 arg3 = &temp3;
29395 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29396 }
29397 }
29398 if (obj3) {
29399 {
29400 arg4 = &temp4;
29401 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29402 }
29403 }
29404 if (obj4) {
29405 ecode5 = SWIG_AsVal_long(obj4, &val5);
29406 if (!SWIG_IsOK(ecode5)) {
29407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29408 }
29409 arg5 = static_cast< long >(val5);
29410 }
29411 if (obj5) {
29412 {
29413 arg6 = wxString_in_helper(obj5);
29414 if (arg6 == NULL) SWIG_fail;
29415 temp6 = true;
29416 }
29417 }
29418 {
29419 if (!wxPyCheckForApp()) SWIG_fail;
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29426 {
29427 if (temp6)
29428 delete arg6;
29429 }
29430 return resultobj;
29431 fail:
29432 {
29433 if (temp6)
29434 delete arg6;
29435 }
29436 return NULL;
29437 }
29438
29439
29440 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29441 PyObject *resultobj = 0;
29442 wxWindow *result = 0 ;
29443
29444 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29445 {
29446 if (!wxPyCheckForApp()) SWIG_fail;
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (wxWindow *)new wxWindow();
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxWindow *arg1 = (wxWindow *) 0 ;
29462 wxWindow *arg2 = (wxWindow *) 0 ;
29463 int arg3 = (int) (int)-1 ;
29464 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29465 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29466 wxSize const &arg5_defvalue = wxDefaultSize ;
29467 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29468 long arg6 = (long) 0 ;
29469 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29470 wxString *arg7 = (wxString *) &arg7_defvalue ;
29471 bool result;
29472 void *argp1 = 0 ;
29473 int res1 = 0 ;
29474 void *argp2 = 0 ;
29475 int res2 = 0 ;
29476 int val3 ;
29477 int ecode3 = 0 ;
29478 wxPoint temp4 ;
29479 wxSize temp5 ;
29480 long val6 ;
29481 int ecode6 = 0 ;
29482 bool temp7 = false ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 PyObject * obj2 = 0 ;
29486 PyObject * obj3 = 0 ;
29487 PyObject * obj4 = 0 ;
29488 PyObject * obj5 = 0 ;
29489 PyObject * obj6 = 0 ;
29490 char * kwnames[] = {
29491 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29492 };
29493
29494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29496 if (!SWIG_IsOK(res1)) {
29497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29498 }
29499 arg1 = reinterpret_cast< wxWindow * >(argp1);
29500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29501 if (!SWIG_IsOK(res2)) {
29502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29503 }
29504 arg2 = reinterpret_cast< wxWindow * >(argp2);
29505 if (obj2) {
29506 ecode3 = SWIG_AsVal_int(obj2, &val3);
29507 if (!SWIG_IsOK(ecode3)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29509 }
29510 arg3 = static_cast< int >(val3);
29511 }
29512 if (obj3) {
29513 {
29514 arg4 = &temp4;
29515 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29516 }
29517 }
29518 if (obj4) {
29519 {
29520 arg5 = &temp5;
29521 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29522 }
29523 }
29524 if (obj5) {
29525 ecode6 = SWIG_AsVal_long(obj5, &val6);
29526 if (!SWIG_IsOK(ecode6)) {
29527 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29528 }
29529 arg6 = static_cast< long >(val6);
29530 }
29531 if (obj6) {
29532 {
29533 arg7 = wxString_in_helper(obj6);
29534 if (arg7 == NULL) SWIG_fail;
29535 temp7 = true;
29536 }
29537 }
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 {
29545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29546 }
29547 {
29548 if (temp7)
29549 delete arg7;
29550 }
29551 return resultobj;
29552 fail:
29553 {
29554 if (temp7)
29555 delete arg7;
29556 }
29557 return NULL;
29558 }
29559
29560
29561 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj = 0;
29563 wxWindow *arg1 = (wxWindow *) 0 ;
29564 bool arg2 = (bool) false ;
29565 bool result;
29566 void *argp1 = 0 ;
29567 int res1 = 0 ;
29568 bool val2 ;
29569 int ecode2 = 0 ;
29570 PyObject * obj0 = 0 ;
29571 PyObject * obj1 = 0 ;
29572 char * kwnames[] = {
29573 (char *) "self",(char *) "force", NULL
29574 };
29575
29576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29578 if (!SWIG_IsOK(res1)) {
29579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29580 }
29581 arg1 = reinterpret_cast< wxWindow * >(argp1);
29582 if (obj1) {
29583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29584 if (!SWIG_IsOK(ecode2)) {
29585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29586 }
29587 arg2 = static_cast< bool >(val2);
29588 }
29589 {
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 result = (bool)(arg1)->Close(arg2);
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 {
29596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29597 }
29598 return resultobj;
29599 fail:
29600 return NULL;
29601 }
29602
29603
29604 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29605 PyObject *resultobj = 0;
29606 wxWindow *arg1 = (wxWindow *) 0 ;
29607 bool result;
29608 void *argp1 = 0 ;
29609 int res1 = 0 ;
29610 PyObject *swig_obj[1] ;
29611
29612 if (!args) SWIG_fail;
29613 swig_obj[0] = args;
29614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29617 }
29618 arg1 = reinterpret_cast< wxWindow * >(argp1);
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (bool)(arg1)->Destroy();
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 {
29626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29635 PyObject *resultobj = 0;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 bool result;
29638 void *argp1 = 0 ;
29639 int res1 = 0 ;
29640 PyObject *swig_obj[1] ;
29641
29642 if (!args) SWIG_fail;
29643 swig_obj[0] = args;
29644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29645 if (!SWIG_IsOK(res1)) {
29646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29647 }
29648 arg1 = reinterpret_cast< wxWindow * >(argp1);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)(arg1)->DestroyChildren();
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 bool result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxWindow * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj = 0;
29696 wxWindow *arg1 = (wxWindow *) 0 ;
29697 wxString *arg2 = 0 ;
29698 void *argp1 = 0 ;
29699 int res1 = 0 ;
29700 bool temp2 = false ;
29701 PyObject * obj0 = 0 ;
29702 PyObject * obj1 = 0 ;
29703 char * kwnames[] = {
29704 (char *) "self",(char *) "label", NULL
29705 };
29706
29707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29709 if (!SWIG_IsOK(res1)) {
29710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29711 }
29712 arg1 = reinterpret_cast< wxWindow * >(argp1);
29713 {
29714 arg2 = wxString_in_helper(obj1);
29715 if (arg2 == NULL) SWIG_fail;
29716 temp2 = true;
29717 }
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 (arg1)->SetLabel((wxString const &)*arg2);
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 resultobj = SWIG_Py_Void();
29725 {
29726 if (temp2)
29727 delete arg2;
29728 }
29729 return resultobj;
29730 fail:
29731 {
29732 if (temp2)
29733 delete arg2;
29734 }
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29740 PyObject *resultobj = 0;
29741 wxWindow *arg1 = (wxWindow *) 0 ;
29742 wxString result;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 PyObject *swig_obj[1] ;
29746
29747 if (!args) SWIG_fail;
29748 swig_obj[0] = args;
29749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29750 if (!SWIG_IsOK(res1)) {
29751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29752 }
29753 arg1 = reinterpret_cast< wxWindow * >(argp1);
29754 {
29755 PyThreadState* __tstate = wxPyBeginAllowThreads();
29756 result = ((wxWindow const *)arg1)->GetLabel();
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 {
29761 #if wxUSE_UNICODE
29762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29763 #else
29764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29765 #endif
29766 }
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj = 0;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 wxString *arg2 = 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 bool temp2 = false ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 char * kwnames[] = {
29783 (char *) "self",(char *) "name", NULL
29784 };
29785
29786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29790 }
29791 arg1 = reinterpret_cast< wxWindow * >(argp1);
29792 {
29793 arg2 = wxString_in_helper(obj1);
29794 if (arg2 == NULL) SWIG_fail;
29795 temp2 = true;
29796 }
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 (arg1)->SetName((wxString const &)*arg2);
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_Py_Void();
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return resultobj;
29809 fail:
29810 {
29811 if (temp2)
29812 delete arg2;
29813 }
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 PyObject *resultobj = 0;
29820 wxWindow *arg1 = (wxWindow *) 0 ;
29821 wxString result;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 PyObject *swig_obj[1] ;
29825
29826 if (!args) SWIG_fail;
29827 swig_obj[0] = args;
29828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29831 }
29832 arg1 = reinterpret_cast< wxWindow * >(argp1);
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = ((wxWindow const *)arg1)->GetName();
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 {
29840 #if wxUSE_UNICODE
29841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29842 #else
29843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29844 #endif
29845 }
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29853 PyObject *resultobj = 0;
29854 wxWindow *arg1 = (wxWindow *) 0 ;
29855 wxWindowVariant arg2 ;
29856 void *argp1 = 0 ;
29857 int res1 = 0 ;
29858 int val2 ;
29859 int ecode2 = 0 ;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char * kwnames[] = {
29863 (char *) "self",(char *) "variant", NULL
29864 };
29865
29866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29868 if (!SWIG_IsOK(res1)) {
29869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29870 }
29871 arg1 = reinterpret_cast< wxWindow * >(argp1);
29872 ecode2 = SWIG_AsVal_int(obj1, &val2);
29873 if (!SWIG_IsOK(ecode2)) {
29874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29875 }
29876 arg2 = static_cast< wxWindowVariant >(val2);
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->SetWindowVariant(arg2);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_Py_Void();
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 wxWindowVariant result;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 PyObject *swig_obj[1] ;
29897
29898 if (!args) SWIG_fail;
29899 swig_obj[0] = args;
29900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29903 }
29904 arg1 = reinterpret_cast< wxWindow * >(argp1);
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 resultobj = SWIG_From_int(static_cast< int >(result));
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj = 0;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 int arg2 ;
29922 void *argp1 = 0 ;
29923 int res1 = 0 ;
29924 int val2 ;
29925 int ecode2 = 0 ;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char * kwnames[] = {
29929 (char *) "self",(char *) "winid", NULL
29930 };
29931
29932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29936 }
29937 arg1 = reinterpret_cast< wxWindow * >(argp1);
29938 ecode2 = SWIG_AsVal_int(obj1, &val2);
29939 if (!SWIG_IsOK(ecode2)) {
29940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29941 }
29942 arg2 = static_cast< int >(val2);
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 (arg1)->SetId(arg2);
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 resultobj = SWIG_Py_Void();
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29957 PyObject *resultobj = 0;
29958 wxWindow *arg1 = (wxWindow *) 0 ;
29959 int result;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 PyObject *swig_obj[1] ;
29963
29964 if (!args) SWIG_fail;
29965 swig_obj[0] = args;
29966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29967 if (!SWIG_IsOK(res1)) {
29968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29969 }
29970 arg1 = reinterpret_cast< wxWindow * >(argp1);
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (int)((wxWindow const *)arg1)->GetId();
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_From_int(static_cast< int >(result));
29978 return resultobj;
29979 fail:
29980 return NULL;
29981 }
29982
29983
29984 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985 PyObject *resultobj = 0;
29986 int result;
29987
29988 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29989 {
29990 PyThreadState* __tstate = wxPyBeginAllowThreads();
29991 result = (int)wxWindow::NewControlId();
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 resultobj = SWIG_From_int(static_cast< int >(result));
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj = 0;
30004 int arg1 ;
30005 int result;
30006 int val1 ;
30007 int ecode1 = 0 ;
30008 PyObject * obj0 = 0 ;
30009 char * kwnames[] = {
30010 (char *) "winid", NULL
30011 };
30012
30013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30014 ecode1 = SWIG_AsVal_int(obj0, &val1);
30015 if (!SWIG_IsOK(ecode1)) {
30016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30017 }
30018 arg1 = static_cast< int >(val1);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (int)wxWindow::NextControlId(arg1);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_From_int(static_cast< int >(result));
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = 0;
30034 int arg1 ;
30035 int result;
30036 int val1 ;
30037 int ecode1 = 0 ;
30038 PyObject * obj0 = 0 ;
30039 char * kwnames[] = {
30040 (char *) "winid", NULL
30041 };
30042
30043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30044 ecode1 = SWIG_AsVal_int(obj0, &val1);
30045 if (!SWIG_IsOK(ecode1)) {
30046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30047 }
30048 arg1 = static_cast< int >(val1);
30049 {
30050 PyThreadState* __tstate = wxPyBeginAllowThreads();
30051 result = (int)wxWindow::PrevControlId(arg1);
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 resultobj = SWIG_From_int(static_cast< int >(result));
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj = 0;
30064 wxWindow *arg1 = (wxWindow *) 0 ;
30065 wxSize *arg2 = 0 ;
30066 void *argp1 = 0 ;
30067 int res1 = 0 ;
30068 wxSize temp2 ;
30069 PyObject * obj0 = 0 ;
30070 PyObject * obj1 = 0 ;
30071 char * kwnames[] = {
30072 (char *) "self",(char *) "size", NULL
30073 };
30074
30075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30077 if (!SWIG_IsOK(res1)) {
30078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30079 }
30080 arg1 = reinterpret_cast< wxWindow * >(argp1);
30081 {
30082 arg2 = &temp2;
30083 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30084 }
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 (arg1)->SetSize((wxSize const &)*arg2);
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = 0;
30100 wxWindow *arg1 = (wxWindow *) 0 ;
30101 int arg2 ;
30102 int arg3 ;
30103 int arg4 ;
30104 int arg5 ;
30105 int arg6 = (int) wxSIZE_AUTO ;
30106 void *argp1 = 0 ;
30107 int res1 = 0 ;
30108 int val2 ;
30109 int ecode2 = 0 ;
30110 int val3 ;
30111 int ecode3 = 0 ;
30112 int val4 ;
30113 int ecode4 = 0 ;
30114 int val5 ;
30115 int ecode5 = 0 ;
30116 int val6 ;
30117 int ecode6 = 0 ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 PyObject * obj2 = 0 ;
30121 PyObject * obj3 = 0 ;
30122 PyObject * obj4 = 0 ;
30123 PyObject * obj5 = 0 ;
30124 char * kwnames[] = {
30125 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30126 };
30127
30128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30132 }
30133 arg1 = reinterpret_cast< wxWindow * >(argp1);
30134 ecode2 = SWIG_AsVal_int(obj1, &val2);
30135 if (!SWIG_IsOK(ecode2)) {
30136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30137 }
30138 arg2 = static_cast< int >(val2);
30139 ecode3 = SWIG_AsVal_int(obj2, &val3);
30140 if (!SWIG_IsOK(ecode3)) {
30141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30142 }
30143 arg3 = static_cast< int >(val3);
30144 ecode4 = SWIG_AsVal_int(obj3, &val4);
30145 if (!SWIG_IsOK(ecode4)) {
30146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30147 }
30148 arg4 = static_cast< int >(val4);
30149 ecode5 = SWIG_AsVal_int(obj4, &val5);
30150 if (!SWIG_IsOK(ecode5)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30152 }
30153 arg5 = static_cast< int >(val5);
30154 if (obj5) {
30155 ecode6 = SWIG_AsVal_int(obj5, &val6);
30156 if (!SWIG_IsOK(ecode6)) {
30157 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30158 }
30159 arg6 = static_cast< int >(val6);
30160 }
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 resultobj = SWIG_Py_Void();
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30175 PyObject *resultobj = 0;
30176 wxWindow *arg1 = (wxWindow *) 0 ;
30177 wxRect *arg2 = 0 ;
30178 int arg3 = (int) wxSIZE_AUTO ;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 wxRect temp2 ;
30182 int val3 ;
30183 int ecode3 = 0 ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 PyObject * obj2 = 0 ;
30187 char * kwnames[] = {
30188 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30189 };
30190
30191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30193 if (!SWIG_IsOK(res1)) {
30194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30195 }
30196 arg1 = reinterpret_cast< wxWindow * >(argp1);
30197 {
30198 arg2 = &temp2;
30199 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30200 }
30201 if (obj2) {
30202 ecode3 = SWIG_AsVal_int(obj2, &val3);
30203 if (!SWIG_IsOK(ecode3)) {
30204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30205 }
30206 arg3 = static_cast< int >(val3);
30207 }
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_Py_Void();
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 int arg2 ;
30225 int arg3 ;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 int val2 ;
30229 int ecode2 = 0 ;
30230 int val3 ;
30231 int ecode3 = 0 ;
30232 PyObject * obj0 = 0 ;
30233 PyObject * obj1 = 0 ;
30234 PyObject * obj2 = 0 ;
30235 char * kwnames[] = {
30236 (char *) "self",(char *) "width",(char *) "height", NULL
30237 };
30238
30239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30241 if (!SWIG_IsOK(res1)) {
30242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30243 }
30244 arg1 = reinterpret_cast< wxWindow * >(argp1);
30245 ecode2 = SWIG_AsVal_int(obj1, &val2);
30246 if (!SWIG_IsOK(ecode2)) {
30247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30248 }
30249 arg2 = static_cast< int >(val2);
30250 ecode3 = SWIG_AsVal_int(obj2, &val3);
30251 if (!SWIG_IsOK(ecode3)) {
30252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30253 }
30254 arg3 = static_cast< int >(val3);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 (arg1)->SetSize(arg2,arg3);
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_Py_Void();
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxPoint *arg2 = 0 ;
30272 int arg3 = (int) wxSIZE_USE_EXISTING ;
30273 void *argp1 = 0 ;
30274 int res1 = 0 ;
30275 wxPoint temp2 ;
30276 int val3 ;
30277 int ecode3 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 PyObject * obj1 = 0 ;
30280 PyObject * obj2 = 0 ;
30281 char * kwnames[] = {
30282 (char *) "self",(char *) "pt",(char *) "flags", NULL
30283 };
30284
30285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30287 if (!SWIG_IsOK(res1)) {
30288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30289 }
30290 arg1 = reinterpret_cast< wxWindow * >(argp1);
30291 {
30292 arg2 = &temp2;
30293 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30294 }
30295 if (obj2) {
30296 ecode3 = SWIG_AsVal_int(obj2, &val3);
30297 if (!SWIG_IsOK(ecode3)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30299 }
30300 arg3 = static_cast< int >(val3);
30301 }
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 (arg1)->Move((wxPoint const &)*arg2,arg3);
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 resultobj = SWIG_Py_Void();
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj = 0;
30317 wxWindow *arg1 = (wxWindow *) 0 ;
30318 int arg2 ;
30319 int arg3 ;
30320 int arg4 = (int) wxSIZE_USE_EXISTING ;
30321 void *argp1 = 0 ;
30322 int res1 = 0 ;
30323 int val2 ;
30324 int ecode2 = 0 ;
30325 int val3 ;
30326 int ecode3 = 0 ;
30327 int val4 ;
30328 int ecode4 = 0 ;
30329 PyObject * obj0 = 0 ;
30330 PyObject * obj1 = 0 ;
30331 PyObject * obj2 = 0 ;
30332 PyObject * obj3 = 0 ;
30333 char * kwnames[] = {
30334 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30335 };
30336
30337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30339 if (!SWIG_IsOK(res1)) {
30340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30341 }
30342 arg1 = reinterpret_cast< wxWindow * >(argp1);
30343 ecode2 = SWIG_AsVal_int(obj1, &val2);
30344 if (!SWIG_IsOK(ecode2)) {
30345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30346 }
30347 arg2 = static_cast< int >(val2);
30348 ecode3 = SWIG_AsVal_int(obj2, &val3);
30349 if (!SWIG_IsOK(ecode3)) {
30350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30351 }
30352 arg3 = static_cast< int >(val3);
30353 if (obj3) {
30354 ecode4 = SWIG_AsVal_int(obj3, &val4);
30355 if (!SWIG_IsOK(ecode4)) {
30356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30357 }
30358 arg4 = static_cast< int >(val4);
30359 }
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 (arg1)->Move(arg2,arg3,arg4);
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 resultobj = SWIG_Py_Void();
30367 return resultobj;
30368 fail:
30369 return NULL;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30374 PyObject *resultobj = 0;
30375 wxWindow *arg1 = (wxWindow *) 0 ;
30376 wxSize const &arg2_defvalue = wxDefaultSize ;
30377 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 wxSize temp2 ;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "self",(char *) "size", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30389 if (!SWIG_IsOK(res1)) {
30390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30391 }
30392 arg1 = reinterpret_cast< wxWindow * >(argp1);
30393 if (obj1) {
30394 {
30395 arg2 = &temp2;
30396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30397 }
30398 }
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_Py_Void();
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxWindow *arg1 = (wxWindow *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30424 }
30425 arg1 = reinterpret_cast< wxWindow * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->Raise();
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30440 PyObject *resultobj = 0;
30441 wxWindow *arg1 = (wxWindow *) 0 ;
30442 void *argp1 = 0 ;
30443 int res1 = 0 ;
30444 PyObject *swig_obj[1] ;
30445
30446 if (!args) SWIG_fail;
30447 swig_obj[0] = args;
30448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30449 if (!SWIG_IsOK(res1)) {
30450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30451 }
30452 arg1 = reinterpret_cast< wxWindow * >(argp1);
30453 {
30454 PyThreadState* __tstate = wxPyBeginAllowThreads();
30455 (arg1)->Lower();
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 resultobj = SWIG_Py_Void();
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30467 PyObject *resultobj = 0;
30468 wxWindow *arg1 = (wxWindow *) 0 ;
30469 wxSize *arg2 = 0 ;
30470 void *argp1 = 0 ;
30471 int res1 = 0 ;
30472 wxSize temp2 ;
30473 PyObject * obj0 = 0 ;
30474 PyObject * obj1 = 0 ;
30475 char * kwnames[] = {
30476 (char *) "self",(char *) "size", NULL
30477 };
30478
30479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30481 if (!SWIG_IsOK(res1)) {
30482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30483 }
30484 arg1 = reinterpret_cast< wxWindow * >(argp1);
30485 {
30486 arg2 = &temp2;
30487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30488 }
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 (arg1)->SetClientSize((wxSize const &)*arg2);
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_Py_Void();
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30503 PyObject *resultobj = 0;
30504 wxWindow *arg1 = (wxWindow *) 0 ;
30505 int arg2 ;
30506 int arg3 ;
30507 void *argp1 = 0 ;
30508 int res1 = 0 ;
30509 int val2 ;
30510 int ecode2 = 0 ;
30511 int val3 ;
30512 int ecode3 = 0 ;
30513 PyObject * obj0 = 0 ;
30514 PyObject * obj1 = 0 ;
30515 PyObject * obj2 = 0 ;
30516 char * kwnames[] = {
30517 (char *) "self",(char *) "width",(char *) "height", NULL
30518 };
30519
30520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30524 }
30525 arg1 = reinterpret_cast< wxWindow * >(argp1);
30526 ecode2 = SWIG_AsVal_int(obj1, &val2);
30527 if (!SWIG_IsOK(ecode2)) {
30528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30529 }
30530 arg2 = static_cast< int >(val2);
30531 ecode3 = SWIG_AsVal_int(obj2, &val3);
30532 if (!SWIG_IsOK(ecode3)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30534 }
30535 arg3 = static_cast< int >(val3);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetClientSize(arg2,arg3);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_Py_Void();
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj = 0;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxRect *arg2 = 0 ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 wxRect temp2 ;
30556 PyObject * obj0 = 0 ;
30557 PyObject * obj1 = 0 ;
30558 char * kwnames[] = {
30559 (char *) "self",(char *) "rect", NULL
30560 };
30561
30562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30566 }
30567 arg1 = reinterpret_cast< wxWindow * >(argp1);
30568 {
30569 arg2 = &temp2;
30570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30571 }
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 (arg1)->SetClientSize((wxRect const &)*arg2);
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 resultobj = SWIG_Py_Void();
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxPoint result;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = ((wxWindow const *)arg1)->GetPosition();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 int *arg2 = (int *) 0 ;
30617 int *arg3 = (int *) 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 int temp2 ;
30621 int res2 = SWIG_TMPOBJ ;
30622 int temp3 ;
30623 int res3 = SWIG_TMPOBJ ;
30624 PyObject *swig_obj[1] ;
30625
30626 arg2 = &temp2;
30627 arg3 = &temp3;
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxWindow * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_Py_Void();
30642 if (SWIG_IsTmpObj(res2)) {
30643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30644 } else {
30645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30647 }
30648 if (SWIG_IsTmpObj(res3)) {
30649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30650 } else {
30651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxPoint result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxWindow * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = ((wxWindow const *)arg1)->GetScreenPosition();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 int *arg2 = (int *) 0 ;
30692 int *arg3 = (int *) 0 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 int temp2 ;
30696 int res2 = SWIG_TMPOBJ ;
30697 int temp3 ;
30698 int res3 = SWIG_TMPOBJ ;
30699 PyObject *swig_obj[1] ;
30700
30701 arg2 = &temp2;
30702 arg3 = &temp3;
30703 if (!args) SWIG_fail;
30704 swig_obj[0] = args;
30705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30706 if (!SWIG_IsOK(res1)) {
30707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30708 }
30709 arg1 = reinterpret_cast< wxWindow * >(argp1);
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 if (SWIG_IsTmpObj(res2)) {
30718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30719 } else {
30720 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30722 }
30723 if (SWIG_IsTmpObj(res3)) {
30724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30725 } else {
30726 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30736 PyObject *resultobj = 0;
30737 wxWindow *arg1 = (wxWindow *) 0 ;
30738 wxRect result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 PyObject *swig_obj[1] ;
30742
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = ((wxWindow const *)arg1)->GetScreenRect();
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 wxSize result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxWindow * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxWindow const *)arg1)->GetSize();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 int *arg2 = (int *) 0 ;
30795 int *arg3 = (int *) 0 ;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 int temp2 ;
30799 int res2 = SWIG_TMPOBJ ;
30800 int temp3 ;
30801 int res3 = SWIG_TMPOBJ ;
30802 PyObject *swig_obj[1] ;
30803
30804 arg2 = &temp2;
30805 arg3 = &temp3;
30806 if (!args) SWIG_fail;
30807 swig_obj[0] = args;
30808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30809 if (!SWIG_IsOK(res1)) {
30810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30811 }
30812 arg1 = reinterpret_cast< wxWindow * >(argp1);
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 resultobj = SWIG_Py_Void();
30820 if (SWIG_IsTmpObj(res2)) {
30821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30822 } else {
30823 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30825 }
30826 if (SWIG_IsTmpObj(res3)) {
30827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30828 } else {
30829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30831 }
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30839 PyObject *resultobj = 0;
30840 wxWindow *arg1 = (wxWindow *) 0 ;
30841 wxRect result;
30842 void *argp1 = 0 ;
30843 int res1 = 0 ;
30844 PyObject *swig_obj[1] ;
30845
30846 if (!args) SWIG_fail;
30847 swig_obj[0] = args;
30848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30849 if (!SWIG_IsOK(res1)) {
30850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30851 }
30852 arg1 = reinterpret_cast< wxWindow * >(argp1);
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = ((wxWindow const *)arg1)->GetRect();
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxWindow *arg1 = (wxWindow *) 0 ;
30869 wxSize result;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = ((wxWindow const *)arg1)->GetClientSize();
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 int *arg2 = (int *) 0 ;
30898 int *arg3 = (int *) 0 ;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 int temp2 ;
30902 int res2 = SWIG_TMPOBJ ;
30903 int temp3 ;
30904 int res3 = SWIG_TMPOBJ ;
30905 PyObject *swig_obj[1] ;
30906
30907 arg2 = &temp2;
30908 arg3 = &temp3;
30909 if (!args) SWIG_fail;
30910 swig_obj[0] = args;
30911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30914 }
30915 arg1 = reinterpret_cast< wxWindow * >(argp1);
30916 {
30917 PyThreadState* __tstate = wxPyBeginAllowThreads();
30918 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 resultobj = SWIG_Py_Void();
30923 if (SWIG_IsTmpObj(res2)) {
30924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30925 } else {
30926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30928 }
30929 if (SWIG_IsTmpObj(res3)) {
30930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30931 } else {
30932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30934 }
30935 return resultobj;
30936 fail:
30937 return NULL;
30938 }
30939
30940
30941 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30942 PyObject *resultobj = 0;
30943 wxWindow *arg1 = (wxWindow *) 0 ;
30944 wxPoint result;
30945 void *argp1 = 0 ;
30946 int res1 = 0 ;
30947 PyObject *swig_obj[1] ;
30948
30949 if (!args) SWIG_fail;
30950 swig_obj[0] = args;
30951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30954 }
30955 arg1 = reinterpret_cast< wxWindow * >(argp1);
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30970 PyObject *resultobj = 0;
30971 wxWindow *arg1 = (wxWindow *) 0 ;
30972 wxRect result;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 PyObject *swig_obj[1] ;
30976
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = ((wxWindow const *)arg1)->GetClientRect();
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 wxSize result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxWindow * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = ((wxWindow const *)arg1)->GetBestSize();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 int *arg2 = (int *) 0 ;
31029 int *arg3 = (int *) 0 ;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 int temp2 ;
31033 int res2 = SWIG_TMPOBJ ;
31034 int temp3 ;
31035 int res3 = SWIG_TMPOBJ ;
31036 PyObject *swig_obj[1] ;
31037
31038 arg2 = &temp2;
31039 arg3 = &temp3;
31040 if (!args) SWIG_fail;
31041 swig_obj[0] = args;
31042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31043 if (!SWIG_IsOK(res1)) {
31044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31045 }
31046 arg1 = reinterpret_cast< wxWindow * >(argp1);
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_Py_Void();
31054 if (SWIG_IsTmpObj(res2)) {
31055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31056 } else {
31057 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31059 }
31060 if (SWIG_IsTmpObj(res3)) {
31061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31062 } else {
31063 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31065 }
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31073 PyObject *resultobj = 0;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 void *argp1 = 0 ;
31076 int res1 = 0 ;
31077 PyObject *swig_obj[1] ;
31078
31079 if (!args) SWIG_fail;
31080 swig_obj[0] = args;
31081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31084 }
31085 arg1 = reinterpret_cast< wxWindow * >(argp1);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 (arg1)->InvalidateBestSize();
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_Py_Void();
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxWindow *arg1 = (wxWindow *) 0 ;
31102 wxSize *arg2 = 0 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 wxSize temp2 ;
31106 PyObject * obj0 = 0 ;
31107 PyObject * obj1 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "size", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 {
31119 arg2 = &temp2;
31120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31121 }
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 resultobj = SWIG_Py_Void();
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31136 PyObject *resultobj = 0;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxSize result;
31139 void *argp1 = 0 ;
31140 int res1 = 0 ;
31141 PyObject *swig_obj[1] ;
31142
31143 if (!args) SWIG_fail;
31144 swig_obj[0] = args;
31145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31146 if (!SWIG_IsOK(res1)) {
31147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31148 }
31149 arg1 = reinterpret_cast< wxWindow * >(argp1);
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 wxSize result;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 PyObject *swig_obj[1] ;
31170
31171 if (!args) SWIG_fail;
31172 swig_obj[0] = args;
31173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31174 if (!SWIG_IsOK(res1)) {
31175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31176 }
31177 arg1 = reinterpret_cast< wxWindow * >(argp1);
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31181 wxPyEndAllowThreads(__tstate);
31182 if (PyErr_Occurred()) SWIG_fail;
31183 }
31184 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 int arg2 = (int) wxBOTH ;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 int val2 ;
31198 int ecode2 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "direction", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31209 }
31210 arg1 = reinterpret_cast< wxWindow * >(argp1);
31211 if (obj1) {
31212 ecode2 = SWIG_AsVal_int(obj1, &val2);
31213 if (!SWIG_IsOK(ecode2)) {
31214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31215 }
31216 arg2 = static_cast< int >(val2);
31217 }
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 (arg1)->Center(arg2);
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_Py_Void();
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31232 PyObject *resultobj = 0;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 int arg2 = (int) wxBOTH ;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 int val2 ;
31238 int ecode2 = 0 ;
31239 PyObject * obj0 = 0 ;
31240 PyObject * obj1 = 0 ;
31241 char * kwnames[] = {
31242 (char *) "self",(char *) "dir", NULL
31243 };
31244
31245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 if (obj1) {
31252 ecode2 = SWIG_AsVal_int(obj1, &val2);
31253 if (!SWIG_IsOK(ecode2)) {
31254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31255 }
31256 arg2 = static_cast< int >(val2);
31257 }
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 (arg1)->CenterOnParent(arg2);
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 resultobj = SWIG_Py_Void();
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31272 PyObject *resultobj = 0;
31273 wxWindow *arg1 = (wxWindow *) 0 ;
31274 void *argp1 = 0 ;
31275 int res1 = 0 ;
31276 PyObject *swig_obj[1] ;
31277
31278 if (!args) SWIG_fail;
31279 swig_obj[0] = args;
31280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31281 if (!SWIG_IsOK(res1)) {
31282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31283 }
31284 arg1 = reinterpret_cast< wxWindow * >(argp1);
31285 {
31286 PyThreadState* __tstate = wxPyBeginAllowThreads();
31287 (arg1)->Fit();
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 resultobj = SWIG_Py_Void();
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31299 PyObject *resultobj = 0;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 void *argp1 = 0 ;
31302 int res1 = 0 ;
31303 PyObject *swig_obj[1] ;
31304
31305 if (!args) SWIG_fail;
31306 swig_obj[0] = args;
31307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31308 if (!SWIG_IsOK(res1)) {
31309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31310 }
31311 arg1 = reinterpret_cast< wxWindow * >(argp1);
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 (arg1)->FitInside();
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 resultobj = SWIG_Py_Void();
31319 return resultobj;
31320 fail:
31321 return NULL;
31322 }
31323
31324
31325 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31326 PyObject *resultobj = 0;
31327 wxWindow *arg1 = (wxWindow *) 0 ;
31328 int arg2 ;
31329 int arg3 ;
31330 int arg4 = (int) -1 ;
31331 int arg5 = (int) -1 ;
31332 int arg6 = (int) -1 ;
31333 int arg7 = (int) -1 ;
31334 void *argp1 = 0 ;
31335 int res1 = 0 ;
31336 int val2 ;
31337 int ecode2 = 0 ;
31338 int val3 ;
31339 int ecode3 = 0 ;
31340 int val4 ;
31341 int ecode4 = 0 ;
31342 int val5 ;
31343 int ecode5 = 0 ;
31344 int val6 ;
31345 int ecode6 = 0 ;
31346 int val7 ;
31347 int ecode7 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 PyObject * obj1 = 0 ;
31350 PyObject * obj2 = 0 ;
31351 PyObject * obj3 = 0 ;
31352 PyObject * obj4 = 0 ;
31353 PyObject * obj5 = 0 ;
31354 PyObject * obj6 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31363 }
31364 arg1 = reinterpret_cast< wxWindow * >(argp1);
31365 ecode2 = SWIG_AsVal_int(obj1, &val2);
31366 if (!SWIG_IsOK(ecode2)) {
31367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31368 }
31369 arg2 = static_cast< int >(val2);
31370 ecode3 = SWIG_AsVal_int(obj2, &val3);
31371 if (!SWIG_IsOK(ecode3)) {
31372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31373 }
31374 arg3 = static_cast< int >(val3);
31375 if (obj3) {
31376 ecode4 = SWIG_AsVal_int(obj3, &val4);
31377 if (!SWIG_IsOK(ecode4)) {
31378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31379 }
31380 arg4 = static_cast< int >(val4);
31381 }
31382 if (obj4) {
31383 ecode5 = SWIG_AsVal_int(obj4, &val5);
31384 if (!SWIG_IsOK(ecode5)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31386 }
31387 arg5 = static_cast< int >(val5);
31388 }
31389 if (obj5) {
31390 ecode6 = SWIG_AsVal_int(obj5, &val6);
31391 if (!SWIG_IsOK(ecode6)) {
31392 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31393 }
31394 arg6 = static_cast< int >(val6);
31395 }
31396 if (obj6) {
31397 ecode7 = SWIG_AsVal_int(obj6, &val7);
31398 if (!SWIG_IsOK(ecode7)) {
31399 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31400 }
31401 arg7 = static_cast< int >(val7);
31402 }
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_Py_Void();
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj = 0;
31418 wxWindow *arg1 = (wxWindow *) 0 ;
31419 wxSize *arg2 = 0 ;
31420 wxSize const &arg3_defvalue = wxDefaultSize ;
31421 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31422 wxSize const &arg4_defvalue = wxDefaultSize ;
31423 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31424 void *argp1 = 0 ;
31425 int res1 = 0 ;
31426 wxSize temp2 ;
31427 wxSize temp3 ;
31428 wxSize temp4 ;
31429 PyObject * obj0 = 0 ;
31430 PyObject * obj1 = 0 ;
31431 PyObject * obj2 = 0 ;
31432 PyObject * obj3 = 0 ;
31433 char * kwnames[] = {
31434 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31435 };
31436
31437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31439 if (!SWIG_IsOK(res1)) {
31440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31441 }
31442 arg1 = reinterpret_cast< wxWindow * >(argp1);
31443 {
31444 arg2 = &temp2;
31445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31446 }
31447 if (obj2) {
31448 {
31449 arg3 = &temp3;
31450 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31451 }
31452 }
31453 if (obj3) {
31454 {
31455 arg4 = &temp4;
31456 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31457 }
31458 }
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj = 0;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 int arg2 ;
31476 int arg3 ;
31477 int arg4 = (int) -1 ;
31478 int arg5 = (int) -1 ;
31479 void *argp1 = 0 ;
31480 int res1 = 0 ;
31481 int val2 ;
31482 int ecode2 = 0 ;
31483 int val3 ;
31484 int ecode3 = 0 ;
31485 int val4 ;
31486 int ecode4 = 0 ;
31487 int val5 ;
31488 int ecode5 = 0 ;
31489 PyObject * obj0 = 0 ;
31490 PyObject * obj1 = 0 ;
31491 PyObject * obj2 = 0 ;
31492 PyObject * obj3 = 0 ;
31493 PyObject * obj4 = 0 ;
31494 char * kwnames[] = {
31495 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31496 };
31497
31498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31500 if (!SWIG_IsOK(res1)) {
31501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31502 }
31503 arg1 = reinterpret_cast< wxWindow * >(argp1);
31504 ecode2 = SWIG_AsVal_int(obj1, &val2);
31505 if (!SWIG_IsOK(ecode2)) {
31506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31507 }
31508 arg2 = static_cast< int >(val2);
31509 ecode3 = SWIG_AsVal_int(obj2, &val3);
31510 if (!SWIG_IsOK(ecode3)) {
31511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31512 }
31513 arg3 = static_cast< int >(val3);
31514 if (obj3) {
31515 ecode4 = SWIG_AsVal_int(obj3, &val4);
31516 if (!SWIG_IsOK(ecode4)) {
31517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31518 }
31519 arg4 = static_cast< int >(val4);
31520 }
31521 if (obj4) {
31522 ecode5 = SWIG_AsVal_int(obj4, &val5);
31523 if (!SWIG_IsOK(ecode5)) {
31524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31525 }
31526 arg5 = static_cast< int >(val5);
31527 }
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_Py_Void();
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj = 0;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 wxSize *arg2 = 0 ;
31545 wxSize const &arg3_defvalue = wxDefaultSize ;
31546 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 wxSize temp2 ;
31550 wxSize temp3 ;
31551 PyObject * obj0 = 0 ;
31552 PyObject * obj1 = 0 ;
31553 PyObject * obj2 = 0 ;
31554 char * kwnames[] = {
31555 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31556 };
31557
31558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31560 if (!SWIG_IsOK(res1)) {
31561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31562 }
31563 arg1 = reinterpret_cast< wxWindow * >(argp1);
31564 {
31565 arg2 = &temp2;
31566 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31567 }
31568 if (obj2) {
31569 {
31570 arg3 = &temp3;
31571 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31572 }
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxSize result;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 PyObject *swig_obj[1] ;
31594
31595 if (!args) SWIG_fail;
31596 swig_obj[0] = args;
31597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = ((wxWindow const *)arg1)->GetMaxSize();
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31616 PyObject *resultobj = 0;
31617 wxWindow *arg1 = (wxWindow *) 0 ;
31618 wxSize result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject *swig_obj[1] ;
31622
31623 if (!args) SWIG_fail;
31624 swig_obj[0] = args;
31625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31628 }
31629 arg1 = reinterpret_cast< wxWindow * >(argp1);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = ((wxWindow const *)arg1)->GetMinSize();
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj = 0;
31645 wxWindow *arg1 = (wxWindow *) 0 ;
31646 wxSize *arg2 = 0 ;
31647 void *argp1 = 0 ;
31648 int res1 = 0 ;
31649 wxSize temp2 ;
31650 PyObject * obj0 = 0 ;
31651 PyObject * obj1 = 0 ;
31652 char * kwnames[] = {
31653 (char *) "self",(char *) "minSize", NULL
31654 };
31655
31656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31660 }
31661 arg1 = reinterpret_cast< wxWindow * >(argp1);
31662 {
31663 arg2 = &temp2;
31664 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31665 }
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 (arg1)->SetMinSize((wxSize const &)*arg2);
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 resultobj = SWIG_Py_Void();
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj = 0;
31681 wxWindow *arg1 = (wxWindow *) 0 ;
31682 wxSize *arg2 = 0 ;
31683 void *argp1 = 0 ;
31684 int res1 = 0 ;
31685 wxSize temp2 ;
31686 PyObject * obj0 = 0 ;
31687 PyObject * obj1 = 0 ;
31688 char * kwnames[] = {
31689 (char *) "self",(char *) "maxSize", NULL
31690 };
31691
31692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31696 }
31697 arg1 = reinterpret_cast< wxWindow * >(argp1);
31698 {
31699 arg2 = &temp2;
31700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31701 }
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->SetMaxSize((wxSize const &)*arg2);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 int result;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 PyObject *swig_obj[1] ;
31722
31723 if (!args) SWIG_fail;
31724 swig_obj[0] = args;
31725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31726 if (!SWIG_IsOK(res1)) {
31727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31728 }
31729 arg1 = reinterpret_cast< wxWindow * >(argp1);
31730 {
31731 PyThreadState* __tstate = wxPyBeginAllowThreads();
31732 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 resultobj = SWIG_From_int(static_cast< int >(result));
31737 return resultobj;
31738 fail:
31739 return NULL;
31740 }
31741
31742
31743 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31744 PyObject *resultobj = 0;
31745 wxWindow *arg1 = (wxWindow *) 0 ;
31746 int result;
31747 void *argp1 = 0 ;
31748 int res1 = 0 ;
31749 PyObject *swig_obj[1] ;
31750
31751 if (!args) SWIG_fail;
31752 swig_obj[0] = args;
31753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31754 if (!SWIG_IsOK(res1)) {
31755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31756 }
31757 arg1 = reinterpret_cast< wxWindow * >(argp1);
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 resultobj = SWIG_From_int(static_cast< int >(result));
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31772 PyObject *resultobj = 0;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 int result;
31775 void *argp1 = 0 ;
31776 int res1 = 0 ;
31777 PyObject *swig_obj[1] ;
31778
31779 if (!args) SWIG_fail;
31780 swig_obj[0] = args;
31781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31782 if (!SWIG_IsOK(res1)) {
31783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31784 }
31785 arg1 = reinterpret_cast< wxWindow * >(argp1);
31786 {
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31789 wxPyEndAllowThreads(__tstate);
31790 if (PyErr_Occurred()) SWIG_fail;
31791 }
31792 resultobj = SWIG_From_int(static_cast< int >(result));
31793 return resultobj;
31794 fail:
31795 return NULL;
31796 }
31797
31798
31799 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31800 PyObject *resultobj = 0;
31801 wxWindow *arg1 = (wxWindow *) 0 ;
31802 int result;
31803 void *argp1 = 0 ;
31804 int res1 = 0 ;
31805 PyObject *swig_obj[1] ;
31806
31807 if (!args) SWIG_fail;
31808 swig_obj[0] = args;
31809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31812 }
31813 arg1 = reinterpret_cast< wxWindow * >(argp1);
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_From_int(static_cast< int >(result));
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31828 PyObject *resultobj = 0;
31829 wxWindow *arg1 = (wxWindow *) 0 ;
31830 wxSize *arg2 = 0 ;
31831 void *argp1 = 0 ;
31832 int res1 = 0 ;
31833 wxSize temp2 ;
31834 PyObject * obj0 = 0 ;
31835 PyObject * obj1 = 0 ;
31836 char * kwnames[] = {
31837 (char *) "self",(char *) "size", NULL
31838 };
31839
31840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31842 if (!SWIG_IsOK(res1)) {
31843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31844 }
31845 arg1 = reinterpret_cast< wxWindow * >(argp1);
31846 {
31847 arg2 = &temp2;
31848 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31849 }
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_Py_Void();
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 int arg2 ;
31867 int arg3 ;
31868 void *argp1 = 0 ;
31869 int res1 = 0 ;
31870 int val2 ;
31871 int ecode2 = 0 ;
31872 int val3 ;
31873 int ecode3 = 0 ;
31874 PyObject * obj0 = 0 ;
31875 PyObject * obj1 = 0 ;
31876 PyObject * obj2 = 0 ;
31877 char * kwnames[] = {
31878 (char *) "self",(char *) "w",(char *) "h", NULL
31879 };
31880
31881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31885 }
31886 arg1 = reinterpret_cast< wxWindow * >(argp1);
31887 ecode2 = SWIG_AsVal_int(obj1, &val2);
31888 if (!SWIG_IsOK(ecode2)) {
31889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31890 }
31891 arg2 = static_cast< int >(val2);
31892 ecode3 = SWIG_AsVal_int(obj2, &val3);
31893 if (!SWIG_IsOK(ecode3)) {
31894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31895 }
31896 arg3 = static_cast< int >(val3);
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 (arg1)->SetVirtualSize(arg2,arg3);
31900 wxPyEndAllowThreads(__tstate);
31901 if (PyErr_Occurred()) SWIG_fail;
31902 }
31903 resultobj = SWIG_Py_Void();
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *resultobj = 0;
31912 wxWindow *arg1 = (wxWindow *) 0 ;
31913 wxSize result;
31914 void *argp1 = 0 ;
31915 int res1 = 0 ;
31916 PyObject *swig_obj[1] ;
31917
31918 if (!args) SWIG_fail;
31919 swig_obj[0] = args;
31920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31921 if (!SWIG_IsOK(res1)) {
31922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31923 }
31924 arg1 = reinterpret_cast< wxWindow * >(argp1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = ((wxWindow const *)arg1)->GetVirtualSize();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 int *arg2 = (int *) 0 ;
31942 int *arg3 = (int *) 0 ;
31943 void *argp1 = 0 ;
31944 int res1 = 0 ;
31945 int temp2 ;
31946 int res2 = SWIG_TMPOBJ ;
31947 int temp3 ;
31948 int res3 = SWIG_TMPOBJ ;
31949 PyObject *swig_obj[1] ;
31950
31951 arg2 = &temp2;
31952 arg3 = &temp3;
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_Py_Void();
31967 if (SWIG_IsTmpObj(res2)) {
31968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31969 } else {
31970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31972 }
31973 if (SWIG_IsTmpObj(res3)) {
31974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31975 } else {
31976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31978 }
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31986 PyObject *resultobj = 0;
31987 wxWindow *arg1 = (wxWindow *) 0 ;
31988 wxSize result;
31989 void *argp1 = 0 ;
31990 int res1 = 0 ;
31991 PyObject *swig_obj[1] ;
31992
31993 if (!args) SWIG_fail;
31994 swig_obj[0] = args;
31995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31996 if (!SWIG_IsOK(res1)) {
31997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31998 }
31999 arg1 = reinterpret_cast< wxWindow * >(argp1);
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32014 PyObject *resultobj = 0;
32015 wxWindow *arg1 = (wxWindow *) 0 ;
32016 bool arg2 = (bool) true ;
32017 bool result;
32018 void *argp1 = 0 ;
32019 int res1 = 0 ;
32020 bool val2 ;
32021 int ecode2 = 0 ;
32022 PyObject * obj0 = 0 ;
32023 PyObject * obj1 = 0 ;
32024 char * kwnames[] = {
32025 (char *) "self",(char *) "show", NULL
32026 };
32027
32028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32030 if (!SWIG_IsOK(res1)) {
32031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32032 }
32033 arg1 = reinterpret_cast< wxWindow * >(argp1);
32034 if (obj1) {
32035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32036 if (!SWIG_IsOK(ecode2)) {
32037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32038 }
32039 arg2 = static_cast< bool >(val2);
32040 }
32041 {
32042 PyThreadState* __tstate = wxPyBeginAllowThreads();
32043 result = (bool)(arg1)->Show(arg2);
32044 wxPyEndAllowThreads(__tstate);
32045 if (PyErr_Occurred()) SWIG_fail;
32046 }
32047 {
32048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32049 }
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *resultobj = 0;
32058 wxWindow *arg1 = (wxWindow *) 0 ;
32059 bool result;
32060 void *argp1 = 0 ;
32061 int res1 = 0 ;
32062 PyObject *swig_obj[1] ;
32063
32064 if (!args) SWIG_fail;
32065 swig_obj[0] = args;
32066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32067 if (!SWIG_IsOK(res1)) {
32068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32069 }
32070 arg1 = reinterpret_cast< wxWindow * >(argp1);
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 result = (bool)(arg1)->Hide();
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 {
32078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32079 }
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 bool arg2 = (bool) true ;
32090 bool result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 bool val2 ;
32094 int ecode2 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "enable", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32105 }
32106 arg1 = reinterpret_cast< wxWindow * >(argp1);
32107 if (obj1) {
32108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32111 }
32112 arg2 = static_cast< bool >(val2);
32113 }
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)(arg1)->Enable(arg2);
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 {
32121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32122 }
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 bool result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 PyObject *swig_obj[1] ;
32136
32137 if (!args) SWIG_fail;
32138 swig_obj[0] = args;
32139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32140 if (!SWIG_IsOK(res1)) {
32141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32142 }
32143 arg1 = reinterpret_cast< wxWindow * >(argp1);
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (bool)(arg1)->Disable();
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 {
32151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 bool result;
32163 void *argp1 = 0 ;
32164 int res1 = 0 ;
32165 PyObject *swig_obj[1] ;
32166
32167 if (!args) SWIG_fail;
32168 swig_obj[0] = args;
32169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = (bool)((wxWindow const *)arg1)->IsShown();
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 {
32181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32182 }
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32190 PyObject *resultobj = 0;
32191 wxWindow *arg1 = (wxWindow *) 0 ;
32192 bool result;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 PyObject *swig_obj[1] ;
32196
32197 if (!args) SWIG_fail;
32198 swig_obj[0] = args;
32199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32200 if (!SWIG_IsOK(res1)) {
32201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32202 }
32203 arg1 = reinterpret_cast< wxWindow * >(argp1);
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32207 wxPyEndAllowThreads(__tstate);
32208 if (PyErr_Occurred()) SWIG_fail;
32209 }
32210 {
32211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32212 }
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 long arg2 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 long val2 ;
32226 int ecode2 = 0 ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char * kwnames[] = {
32230 (char *) "self",(char *) "style", NULL
32231 };
32232
32233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32235 if (!SWIG_IsOK(res1)) {
32236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32237 }
32238 arg1 = reinterpret_cast< wxWindow * >(argp1);
32239 ecode2 = SWIG_AsVal_long(obj1, &val2);
32240 if (!SWIG_IsOK(ecode2)) {
32241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32242 }
32243 arg2 = static_cast< long >(val2);
32244 {
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 (arg1)->SetWindowStyleFlag(arg2);
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 resultobj = SWIG_Py_Void();
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32258 PyObject *resultobj = 0;
32259 wxWindow *arg1 = (wxWindow *) 0 ;
32260 long result;
32261 void *argp1 = 0 ;
32262 int res1 = 0 ;
32263 PyObject *swig_obj[1] ;
32264
32265 if (!args) SWIG_fail;
32266 swig_obj[0] = args;
32267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32268 if (!SWIG_IsOK(res1)) {
32269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32270 }
32271 arg1 = reinterpret_cast< wxWindow * >(argp1);
32272 {
32273 PyThreadState* __tstate = wxPyBeginAllowThreads();
32274 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32275 wxPyEndAllowThreads(__tstate);
32276 if (PyErr_Occurred()) SWIG_fail;
32277 }
32278 resultobj = SWIG_From_long(static_cast< long >(result));
32279 return resultobj;
32280 fail:
32281 return NULL;
32282 }
32283
32284
32285 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj = 0;
32287 wxWindow *arg1 = (wxWindow *) 0 ;
32288 int arg2 ;
32289 bool result;
32290 void *argp1 = 0 ;
32291 int res1 = 0 ;
32292 int val2 ;
32293 int ecode2 = 0 ;
32294 PyObject * obj0 = 0 ;
32295 PyObject * obj1 = 0 ;
32296 char * kwnames[] = {
32297 (char *) "self",(char *) "flag", NULL
32298 };
32299
32300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32302 if (!SWIG_IsOK(res1)) {
32303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32304 }
32305 arg1 = reinterpret_cast< wxWindow * >(argp1);
32306 ecode2 = SWIG_AsVal_int(obj1, &val2);
32307 if (!SWIG_IsOK(ecode2)) {
32308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32309 }
32310 arg2 = static_cast< int >(val2);
32311 {
32312 PyThreadState* __tstate = wxPyBeginAllowThreads();
32313 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 {
32318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32319 }
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxWindow *arg1 = (wxWindow *) 0 ;
32329 bool result;
32330 void *argp1 = 0 ;
32331 int res1 = 0 ;
32332 PyObject *swig_obj[1] ;
32333
32334 if (!args) SWIG_fail;
32335 swig_obj[0] = args;
32336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32337 if (!SWIG_IsOK(res1)) {
32338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32339 }
32340 arg1 = reinterpret_cast< wxWindow * >(argp1);
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = (bool)((wxWindow const *)arg1)->IsRetained();
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxWindow *arg1 = (wxWindow *) 0 ;
32359 long arg2 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 long val2 ;
32363 int ecode2 = 0 ;
32364 PyObject * obj0 = 0 ;
32365 PyObject * obj1 = 0 ;
32366 char * kwnames[] = {
32367 (char *) "self",(char *) "exStyle", NULL
32368 };
32369
32370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 ecode2 = SWIG_AsVal_long(obj1, &val2);
32377 if (!SWIG_IsOK(ecode2)) {
32378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32379 }
32380 arg2 = static_cast< long >(val2);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 (arg1)->SetExtraStyle(arg2);
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_Py_Void();
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 long result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 resultobj = SWIG_From_long(static_cast< long >(result));
32416 return resultobj;
32417 fail:
32418 return NULL;
32419 }
32420
32421
32422 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32423 PyObject *resultobj = 0;
32424 wxWindow *arg1 = (wxWindow *) 0 ;
32425 bool arg2 = (bool) true ;
32426 void *argp1 = 0 ;
32427 int res1 = 0 ;
32428 bool val2 ;
32429 int ecode2 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 PyObject * obj1 = 0 ;
32432 char * kwnames[] = {
32433 (char *) "self",(char *) "modal", NULL
32434 };
32435
32436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32440 }
32441 arg1 = reinterpret_cast< wxWindow * >(argp1);
32442 if (obj1) {
32443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32444 if (!SWIG_IsOK(ecode2)) {
32445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32446 }
32447 arg2 = static_cast< bool >(val2);
32448 }
32449 {
32450 PyThreadState* __tstate = wxPyBeginAllowThreads();
32451 (arg1)->MakeModal(arg2);
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 resultobj = SWIG_Py_Void();
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj = 0;
32464 wxWindow *arg1 = (wxWindow *) 0 ;
32465 bool arg2 ;
32466 void *argp1 = 0 ;
32467 int res1 = 0 ;
32468 bool val2 ;
32469 int ecode2 = 0 ;
32470 PyObject * obj0 = 0 ;
32471 PyObject * obj1 = 0 ;
32472 char * kwnames[] = {
32473 (char *) "self",(char *) "enableTheme", NULL
32474 };
32475
32476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32480 }
32481 arg1 = reinterpret_cast< wxWindow * >(argp1);
32482 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32483 if (!SWIG_IsOK(ecode2)) {
32484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32485 }
32486 arg2 = static_cast< bool >(val2);
32487 {
32488 PyThreadState* __tstate = wxPyBeginAllowThreads();
32489 (arg1)->SetThemeEnabled(arg2);
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 resultobj = SWIG_Py_Void();
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 void *argp1 = 0 ;
32534 int res1 = 0 ;
32535 PyObject *swig_obj[1] ;
32536
32537 if (!args) SWIG_fail;
32538 swig_obj[0] = args;
32539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32540 if (!SWIG_IsOK(res1)) {
32541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32542 }
32543 arg1 = reinterpret_cast< wxWindow * >(argp1);
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 (arg1)->SetFocus();
32547 wxPyEndAllowThreads(__tstate);
32548 if (PyErr_Occurred()) SWIG_fail;
32549 }
32550 resultobj = SWIG_Py_Void();
32551 return resultobj;
32552 fail:
32553 return NULL;
32554 }
32555
32556
32557 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32558 PyObject *resultobj = 0;
32559 wxWindow *arg1 = (wxWindow *) 0 ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 PyObject *swig_obj[1] ;
32563
32564 if (!args) SWIG_fail;
32565 swig_obj[0] = args;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->SetFocusFromKbd();
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxWindow *result = 0 ;
32587
32588 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32589 {
32590 if (!wxPyCheckForApp()) SWIG_fail;
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (wxWindow *)wxWindow::FindFocus();
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = wxPyMake_wxObject(result, 0);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *resultobj = 0;
32607 wxWindow *arg1 = (wxWindow *) 0 ;
32608 bool result;
32609 void *argp1 = 0 ;
32610 int res1 = 0 ;
32611 PyObject *swig_obj[1] ;
32612
32613 if (!args) SWIG_fail;
32614 swig_obj[0] = args;
32615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32618 }
32619 arg1 = reinterpret_cast< wxWindow * >(argp1);
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 {
32627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32628 }
32629 return resultobj;
32630 fail:
32631 return NULL;
32632 }
32633
32634
32635 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32636 PyObject *resultobj = 0;
32637 wxWindow *arg1 = (wxWindow *) 0 ;
32638 bool result;
32639 void *argp1 = 0 ;
32640 int res1 = 0 ;
32641 PyObject *swig_obj[1] ;
32642
32643 if (!args) SWIG_fail;
32644 swig_obj[0] = args;
32645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32646 if (!SWIG_IsOK(res1)) {
32647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32648 }
32649 arg1 = reinterpret_cast< wxWindow * >(argp1);
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32653 wxPyEndAllowThreads(__tstate);
32654 if (PyErr_Occurred()) SWIG_fail;
32655 }
32656 {
32657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32658 }
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32666 PyObject *resultobj = 0;
32667 wxWindow *arg1 = (wxWindow *) 0 ;
32668 wxWindow *result = 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 PyObject *swig_obj[1] ;
32672
32673 if (!args) SWIG_fail;
32674 swig_obj[0] = args;
32675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32678 }
32679 arg1 = reinterpret_cast< wxWindow * >(argp1);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 {
32687 resultobj = wxPyMake_wxObject(result, 0);
32688 }
32689 return resultobj;
32690 fail:
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj = 0;
32697 wxWindow *arg1 = (wxWindow *) 0 ;
32698 wxWindow *arg2 = (wxWindow *) 0 ;
32699 wxWindow *result = 0 ;
32700 void *argp1 = 0 ;
32701 int res1 = 0 ;
32702 void *argp2 = 0 ;
32703 int res2 = 0 ;
32704 PyObject * obj0 = 0 ;
32705 PyObject * obj1 = 0 ;
32706 char * kwnames[] = {
32707 (char *) "self",(char *) "child", NULL
32708 };
32709
32710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32712 if (!SWIG_IsOK(res1)) {
32713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32714 }
32715 arg1 = reinterpret_cast< wxWindow * >(argp1);
32716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32717 if (!SWIG_IsOK(res2)) {
32718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32719 }
32720 arg2 = reinterpret_cast< wxWindow * >(argp2);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 {
32728 resultobj = wxPyMake_wxObject(result, 0);
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 wxWindow *arg2 = (wxWindow *) 0 ;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 void *argp2 = 0 ;
32743 int res2 = 0 ;
32744 PyObject * obj0 = 0 ;
32745 PyObject * obj1 = 0 ;
32746 char * kwnames[] = {
32747 (char *) "self",(char *) "win", NULL
32748 };
32749
32750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32754 }
32755 arg1 = reinterpret_cast< wxWindow * >(argp1);
32756 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32757 if (!SWIG_IsOK(res2)) {
32758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32759 }
32760 arg2 = reinterpret_cast< wxWindow * >(argp2);
32761 {
32762 PyThreadState* __tstate = wxPyBeginAllowThreads();
32763 (arg1)->SetTmpDefaultItem(arg2);
32764 wxPyEndAllowThreads(__tstate);
32765 if (PyErr_Occurred()) SWIG_fail;
32766 }
32767 resultobj = SWIG_Py_Void();
32768 return resultobj;
32769 fail:
32770 return NULL;
32771 }
32772
32773
32774 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32775 PyObject *resultobj = 0;
32776 wxWindow *arg1 = (wxWindow *) 0 ;
32777 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32778 bool result;
32779 void *argp1 = 0 ;
32780 int res1 = 0 ;
32781 int val2 ;
32782 int ecode2 = 0 ;
32783 PyObject * obj0 = 0 ;
32784 PyObject * obj1 = 0 ;
32785 char * kwnames[] = {
32786 (char *) "self",(char *) "flags", NULL
32787 };
32788
32789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32793 }
32794 arg1 = reinterpret_cast< wxWindow * >(argp1);
32795 if (obj1) {
32796 ecode2 = SWIG_AsVal_int(obj1, &val2);
32797 if (!SWIG_IsOK(ecode2)) {
32798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32799 }
32800 arg2 = static_cast< int >(val2);
32801 }
32802 {
32803 PyThreadState* __tstate = wxPyBeginAllowThreads();
32804 result = (bool)(arg1)->Navigate(arg2);
32805 wxPyEndAllowThreads(__tstate);
32806 if (PyErr_Occurred()) SWIG_fail;
32807 }
32808 {
32809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32810 }
32811 return resultobj;
32812 fail:
32813 return NULL;
32814 }
32815
32816
32817 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj = 0;
32819 wxWindow *arg1 = (wxWindow *) 0 ;
32820 wxWindow *arg2 = (wxWindow *) 0 ;
32821 void *argp1 = 0 ;
32822 int res1 = 0 ;
32823 void *argp2 = 0 ;
32824 int res2 = 0 ;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 char * kwnames[] = {
32828 (char *) "self",(char *) "win", NULL
32829 };
32830
32831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res2)) {
32839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32840 }
32841 arg2 = reinterpret_cast< wxWindow * >(argp2);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 (arg1)->MoveAfterInTabOrder(arg2);
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 resultobj = SWIG_Py_Void();
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32856 PyObject *resultobj = 0;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 wxWindow *arg2 = (wxWindow *) 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 void *argp2 = 0 ;
32862 int res2 = 0 ;
32863 PyObject * obj0 = 0 ;
32864 PyObject * obj1 = 0 ;
32865 char * kwnames[] = {
32866 (char *) "self",(char *) "win", NULL
32867 };
32868
32869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32873 }
32874 arg1 = reinterpret_cast< wxWindow * >(argp1);
32875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32876 if (!SWIG_IsOK(res2)) {
32877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32878 }
32879 arg2 = reinterpret_cast< wxWindow * >(argp2);
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 (arg1)->MoveBeforeInTabOrder(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 resultobj = SWIG_Py_Void();
32887 return resultobj;
32888 fail:
32889 return NULL;
32890 }
32891
32892
32893 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32894 PyObject *resultobj = 0;
32895 wxWindow *arg1 = (wxWindow *) 0 ;
32896 PyObject *result = 0 ;
32897 void *argp1 = 0 ;
32898 int res1 = 0 ;
32899 PyObject *swig_obj[1] ;
32900
32901 if (!args) SWIG_fail;
32902 swig_obj[0] = args;
32903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32904 if (!SWIG_IsOK(res1)) {
32905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32906 }
32907 arg1 = reinterpret_cast< wxWindow * >(argp1);
32908 {
32909 PyThreadState* __tstate = wxPyBeginAllowThreads();
32910 result = (PyObject *)wxWindow_GetChildren(arg1);
32911 wxPyEndAllowThreads(__tstate);
32912 if (PyErr_Occurred()) SWIG_fail;
32913 }
32914 resultobj = result;
32915 return resultobj;
32916 fail:
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32922 PyObject *resultobj = 0;
32923 wxWindow *arg1 = (wxWindow *) 0 ;
32924 wxWindow *result = 0 ;
32925 void *argp1 = 0 ;
32926 int res1 = 0 ;
32927 PyObject *swig_obj[1] ;
32928
32929 if (!args) SWIG_fail;
32930 swig_obj[0] = args;
32931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res1)) {
32933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32934 }
32935 arg1 = reinterpret_cast< wxWindow * >(argp1);
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 {
32943 resultobj = wxPyMake_wxObject(result, 0);
32944 }
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32952 PyObject *resultobj = 0;
32953 wxWindow *arg1 = (wxWindow *) 0 ;
32954 wxWindow *result = 0 ;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 PyObject *swig_obj[1] ;
32958
32959 if (!args) SWIG_fail;
32960 swig_obj[0] = args;
32961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32969 wxPyEndAllowThreads(__tstate);
32970 if (PyErr_Occurred()) SWIG_fail;
32971 }
32972 {
32973 resultobj = wxPyMake_wxObject(result, 0);
32974 }
32975 return resultobj;
32976 fail:
32977 return NULL;
32978 }
32979
32980
32981 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32982 PyObject *resultobj = 0;
32983 wxWindow *arg1 = (wxWindow *) 0 ;
32984 bool result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 PyObject *swig_obj[1] ;
32988
32989 if (!args) SWIG_fail;
32990 swig_obj[0] = args;
32991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32992 if (!SWIG_IsOK(res1)) {
32993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32994 }
32995 arg1 = reinterpret_cast< wxWindow * >(argp1);
32996 {
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33004 }
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 wxWindow *arg2 = (wxWindow *) 0 ;
33015 bool result;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 void *argp2 = 0 ;
33019 int res2 = 0 ;
33020 PyObject * obj0 = 0 ;
33021 PyObject * obj1 = 0 ;
33022 char * kwnames[] = {
33023 (char *) "self",(char *) "newParent", NULL
33024 };
33025
33026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33028 if (!SWIG_IsOK(res1)) {
33029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33030 }
33031 arg1 = reinterpret_cast< wxWindow * >(argp1);
33032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res2)) {
33034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33035 }
33036 arg2 = reinterpret_cast< wxWindow * >(argp2);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (bool)(arg1)->Reparent(arg2);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 wxWindow *arg2 = (wxWindow *) 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 void *argp2 = 0 ;
33059 int res2 = 0 ;
33060 PyObject * obj0 = 0 ;
33061 PyObject * obj1 = 0 ;
33062 char * kwnames[] = {
33063 (char *) "self",(char *) "child", NULL
33064 };
33065
33066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33068 if (!SWIG_IsOK(res1)) {
33069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33070 }
33071 arg1 = reinterpret_cast< wxWindow * >(argp1);
33072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33073 if (!SWIG_IsOK(res2)) {
33074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33075 }
33076 arg2 = reinterpret_cast< wxWindow * >(argp2);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 (arg1)->AddChild(arg2);
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 resultobj = SWIG_Py_Void();
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = 0;
33092 wxWindow *arg1 = (wxWindow *) 0 ;
33093 wxWindow *arg2 = (wxWindow *) 0 ;
33094 void *argp1 = 0 ;
33095 int res1 = 0 ;
33096 void *argp2 = 0 ;
33097 int res2 = 0 ;
33098 PyObject * obj0 = 0 ;
33099 PyObject * obj1 = 0 ;
33100 char * kwnames[] = {
33101 (char *) "self",(char *) "child", NULL
33102 };
33103
33104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33111 if (!SWIG_IsOK(res2)) {
33112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33113 }
33114 arg2 = reinterpret_cast< wxWindow * >(argp2);
33115 {
33116 PyThreadState* __tstate = wxPyBeginAllowThreads();
33117 (arg1)->RemoveChild(arg2);
33118 wxPyEndAllowThreads(__tstate);
33119 if (PyErr_Occurred()) SWIG_fail;
33120 }
33121 resultobj = SWIG_Py_Void();
33122 return resultobj;
33123 fail:
33124 return NULL;
33125 }
33126
33127
33128 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33129 PyObject *resultobj = 0;
33130 wxWindow *arg1 = (wxWindow *) 0 ;
33131 long arg2 ;
33132 wxWindow *result = 0 ;
33133 void *argp1 = 0 ;
33134 int res1 = 0 ;
33135 long val2 ;
33136 int ecode2 = 0 ;
33137 PyObject * obj0 = 0 ;
33138 PyObject * obj1 = 0 ;
33139 char * kwnames[] = {
33140 (char *) "self",(char *) "winid", NULL
33141 };
33142
33143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33147 }
33148 arg1 = reinterpret_cast< wxWindow * >(argp1);
33149 ecode2 = SWIG_AsVal_long(obj1, &val2);
33150 if (!SWIG_IsOK(ecode2)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33152 }
33153 arg2 = static_cast< long >(val2);
33154 {
33155 PyThreadState* __tstate = wxPyBeginAllowThreads();
33156 result = (wxWindow *)(arg1)->FindWindow(arg2);
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 {
33161 resultobj = wxPyMake_wxObject(result, 0);
33162 }
33163 return resultobj;
33164 fail:
33165 return NULL;
33166 }
33167
33168
33169 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33170 PyObject *resultobj = 0;
33171 wxWindow *arg1 = (wxWindow *) 0 ;
33172 wxString *arg2 = 0 ;
33173 wxWindow *result = 0 ;
33174 void *argp1 = 0 ;
33175 int res1 = 0 ;
33176 bool temp2 = false ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 char * kwnames[] = {
33180 (char *) "self",(char *) "name", NULL
33181 };
33182
33183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33185 if (!SWIG_IsOK(res1)) {
33186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33187 }
33188 arg1 = reinterpret_cast< wxWindow * >(argp1);
33189 {
33190 arg2 = wxString_in_helper(obj1);
33191 if (arg2 == NULL) SWIG_fail;
33192 temp2 = true;
33193 }
33194 {
33195 PyThreadState* __tstate = wxPyBeginAllowThreads();
33196 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = wxPyMake_wxObject(result, 0);
33202 }
33203 {
33204 if (temp2)
33205 delete arg2;
33206 }
33207 return resultobj;
33208 fail:
33209 {
33210 if (temp2)
33211 delete arg2;
33212 }
33213 return NULL;
33214 }
33215
33216
33217 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33218 PyObject *resultobj = 0;
33219 wxWindow *arg1 = (wxWindow *) 0 ;
33220 wxEvtHandler *result = 0 ;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 PyObject *swig_obj[1] ;
33224
33225 if (!args) SWIG_fail;
33226 swig_obj[0] = args;
33227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33230 }
33231 arg1 = reinterpret_cast< wxWindow * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 {
33239 resultobj = wxPyMake_wxObject(result, 0);
33240 }
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = 0;
33249 wxWindow *arg1 = (wxWindow *) 0 ;
33250 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33251 void *argp1 = 0 ;
33252 int res1 = 0 ;
33253 void *argp2 = 0 ;
33254 int res2 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char * kwnames[] = {
33258 (char *) "self",(char *) "handler", NULL
33259 };
33260
33261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33263 if (!SWIG_IsOK(res1)) {
33264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33265 }
33266 arg1 = reinterpret_cast< wxWindow * >(argp1);
33267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33268 if (!SWIG_IsOK(res2)) {
33269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33270 }
33271 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 (arg1)->SetEventHandler(arg2);
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 resultobj = SWIG_Py_Void();
33279 return resultobj;
33280 fail:
33281 return NULL;
33282 }
33283
33284
33285 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33286 PyObject *resultobj = 0;
33287 wxWindow *arg1 = (wxWindow *) 0 ;
33288 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33289 void *argp1 = 0 ;
33290 int res1 = 0 ;
33291 void *argp2 = 0 ;
33292 int res2 = 0 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 char * kwnames[] = {
33296 (char *) "self",(char *) "handler", NULL
33297 };
33298
33299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33306 if (!SWIG_IsOK(res2)) {
33307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33308 }
33309 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 (arg1)->PushEventHandler(arg2);
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 resultobj = SWIG_Py_Void();
33317 return resultobj;
33318 fail:
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33324 PyObject *resultobj = 0;
33325 wxWindow *arg1 = (wxWindow *) 0 ;
33326 bool arg2 = (bool) false ;
33327 wxEvtHandler *result = 0 ;
33328 void *argp1 = 0 ;
33329 int res1 = 0 ;
33330 bool val2 ;
33331 int ecode2 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 char * kwnames[] = {
33335 (char *) "self",(char *) "deleteHandler", NULL
33336 };
33337
33338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33340 if (!SWIG_IsOK(res1)) {
33341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33342 }
33343 arg1 = reinterpret_cast< wxWindow * >(argp1);
33344 if (obj1) {
33345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33346 if (!SWIG_IsOK(ecode2)) {
33347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33348 }
33349 arg2 = static_cast< bool >(val2);
33350 }
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 resultobj = wxPyMake_wxObject(result, 0);
33359 }
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj = 0;
33368 wxWindow *arg1 = (wxWindow *) 0 ;
33369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33370 bool result;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 void *argp2 = 0 ;
33374 int res2 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "self",(char *) "handler", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33388 if (!SWIG_IsOK(res2)) {
33389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33390 }
33391 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 result = (bool)(arg1)->RemoveEventHandler(arg2);
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 {
33399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33400 }
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33408 PyObject *resultobj = 0;
33409 wxWindow *arg1 = (wxWindow *) 0 ;
33410 wxValidator *arg2 = 0 ;
33411 void *argp1 = 0 ;
33412 int res1 = 0 ;
33413 void *argp2 = 0 ;
33414 int res2 = 0 ;
33415 PyObject * obj0 = 0 ;
33416 PyObject * obj1 = 0 ;
33417 char * kwnames[] = {
33418 (char *) "self",(char *) "validator", NULL
33419 };
33420
33421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33428 if (!SWIG_IsOK(res2)) {
33429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33430 }
33431 if (!argp2) {
33432 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33433 }
33434 arg2 = reinterpret_cast< wxValidator * >(argp2);
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 (arg1)->SetValidator((wxValidator const &)*arg2);
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 resultobj = SWIG_Py_Void();
33442 return resultobj;
33443 fail:
33444 return NULL;
33445 }
33446
33447
33448 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33449 PyObject *resultobj = 0;
33450 wxWindow *arg1 = (wxWindow *) 0 ;
33451 wxValidator *result = 0 ;
33452 void *argp1 = 0 ;
33453 int res1 = 0 ;
33454 PyObject *swig_obj[1] ;
33455
33456 if (!args) SWIG_fail;
33457 swig_obj[0] = args;
33458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33459 if (!SWIG_IsOK(res1)) {
33460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33461 }
33462 arg1 = reinterpret_cast< wxWindow * >(argp1);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (wxValidator *)(arg1)->GetValidator();
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 {
33470 resultobj = wxPyMake_wxObject(result, (bool)0);
33471 }
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33479 PyObject *resultobj = 0;
33480 wxWindow *arg1 = (wxWindow *) 0 ;
33481 bool result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 PyObject *swig_obj[1] ;
33485
33486 if (!args) SWIG_fail;
33487 swig_obj[0] = args;
33488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33489 if (!SWIG_IsOK(res1)) {
33490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33491 }
33492 arg1 = reinterpret_cast< wxWindow * >(argp1);
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (bool)(arg1)->Validate();
33496 wxPyEndAllowThreads(__tstate);
33497 if (PyErr_Occurred()) SWIG_fail;
33498 }
33499 {
33500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33501 }
33502 return resultobj;
33503 fail:
33504 return NULL;
33505 }
33506
33507
33508 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33509 PyObject *resultobj = 0;
33510 wxWindow *arg1 = (wxWindow *) 0 ;
33511 bool result;
33512 void *argp1 = 0 ;
33513 int res1 = 0 ;
33514 PyObject *swig_obj[1] ;
33515
33516 if (!args) SWIG_fail;
33517 swig_obj[0] = args;
33518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 result = (bool)(arg1)->TransferDataToWindow();
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 {
33530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33531 }
33532 return resultobj;
33533 fail:
33534 return NULL;
33535 }
33536
33537
33538 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33539 PyObject *resultobj = 0;
33540 wxWindow *arg1 = (wxWindow *) 0 ;
33541 bool result;
33542 void *argp1 = 0 ;
33543 int res1 = 0 ;
33544 PyObject *swig_obj[1] ;
33545
33546 if (!args) SWIG_fail;
33547 swig_obj[0] = args;
33548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33549 if (!SWIG_IsOK(res1)) {
33550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33551 }
33552 arg1 = reinterpret_cast< wxWindow * >(argp1);
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (bool)(arg1)->TransferDataFromWindow();
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *resultobj = 0;
33570 wxWindow *arg1 = (wxWindow *) 0 ;
33571 void *argp1 = 0 ;
33572 int res1 = 0 ;
33573 PyObject *swig_obj[1] ;
33574
33575 if (!args) SWIG_fail;
33576 swig_obj[0] = args;
33577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 {
33583 PyThreadState* __tstate = wxPyBeginAllowThreads();
33584 (arg1)->InitDialog();
33585 wxPyEndAllowThreads(__tstate);
33586 if (PyErr_Occurred()) SWIG_fail;
33587 }
33588 resultobj = SWIG_Py_Void();
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33596 PyObject *resultobj = 0;
33597 wxWindow *arg1 = (wxWindow *) 0 ;
33598 wxAcceleratorTable *arg2 = 0 ;
33599 void *argp1 = 0 ;
33600 int res1 = 0 ;
33601 void *argp2 = 0 ;
33602 int res2 = 0 ;
33603 PyObject * obj0 = 0 ;
33604 PyObject * obj1 = 0 ;
33605 char * kwnames[] = {
33606 (char *) "self",(char *) "accel", NULL
33607 };
33608
33609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33611 if (!SWIG_IsOK(res1)) {
33612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33613 }
33614 arg1 = reinterpret_cast< wxWindow * >(argp1);
33615 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33616 if (!SWIG_IsOK(res2)) {
33617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33618 }
33619 if (!argp2) {
33620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33621 }
33622 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33626 wxPyEndAllowThreads(__tstate);
33627 if (PyErr_Occurred()) SWIG_fail;
33628 }
33629 resultobj = SWIG_Py_Void();
33630 return resultobj;
33631 fail:
33632 return NULL;
33633 }
33634
33635
33636 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33637 PyObject *resultobj = 0;
33638 wxWindow *arg1 = (wxWindow *) 0 ;
33639 wxAcceleratorTable *result = 0 ;
33640 void *argp1 = 0 ;
33641 int res1 = 0 ;
33642 PyObject *swig_obj[1] ;
33643
33644 if (!args) SWIG_fail;
33645 swig_obj[0] = args;
33646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33647 if (!SWIG_IsOK(res1)) {
33648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33649 }
33650 arg1 = reinterpret_cast< wxWindow * >(argp1);
33651 {
33652 PyThreadState* __tstate = wxPyBeginAllowThreads();
33653 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33654 wxPyEndAllowThreads(__tstate);
33655 if (PyErr_Occurred()) SWIG_fail;
33656 }
33657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33658 return resultobj;
33659 fail:
33660 return NULL;
33661 }
33662
33663
33664 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33665 PyObject *resultobj = 0;
33666 wxWindow *arg1 = (wxWindow *) 0 ;
33667 int arg2 ;
33668 int arg3 ;
33669 int arg4 ;
33670 bool result;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 int val2 ;
33674 int ecode2 = 0 ;
33675 int val3 ;
33676 int ecode3 = 0 ;
33677 int val4 ;
33678 int ecode4 = 0 ;
33679 PyObject * obj0 = 0 ;
33680 PyObject * obj1 = 0 ;
33681 PyObject * obj2 = 0 ;
33682 PyObject * obj3 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 ecode2 = SWIG_AsVal_int(obj1, &val2);
33694 if (!SWIG_IsOK(ecode2)) {
33695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33696 }
33697 arg2 = static_cast< int >(val2);
33698 ecode3 = SWIG_AsVal_int(obj2, &val3);
33699 if (!SWIG_IsOK(ecode3)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33701 }
33702 arg3 = static_cast< int >(val3);
33703 ecode4 = SWIG_AsVal_int(obj3, &val4);
33704 if (!SWIG_IsOK(ecode4)) {
33705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33706 }
33707 arg4 = static_cast< int >(val4);
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33716 }
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 int arg2 ;
33727 bool result;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 int val2 ;
33731 int ecode2 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "hotkeyId", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 ecode2 = SWIG_AsVal_int(obj1, &val2);
33745 if (!SWIG_IsOK(ecode2)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33747 }
33748 arg2 = static_cast< int >(val2);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 {
33756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33757 }
33758 return resultobj;
33759 fail:
33760 return NULL;
33761 }
33762
33763
33764 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33765 PyObject *resultobj = 0;
33766 wxWindow *arg1 = (wxWindow *) 0 ;
33767 wxPoint *arg2 = 0 ;
33768 wxPoint result;
33769 void *argp1 = 0 ;
33770 int res1 = 0 ;
33771 wxPoint temp2 ;
33772 PyObject * obj0 = 0 ;
33773 PyObject * obj1 = 0 ;
33774 char * kwnames[] = {
33775 (char *) "self",(char *) "pt", NULL
33776 };
33777
33778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33782 }
33783 arg1 = reinterpret_cast< wxWindow * >(argp1);
33784 {
33785 arg2 = &temp2;
33786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33787 }
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33802 PyObject *resultobj = 0;
33803 wxWindow *arg1 = (wxWindow *) 0 ;
33804 wxSize *arg2 = 0 ;
33805 wxSize result;
33806 void *argp1 = 0 ;
33807 int res1 = 0 ;
33808 wxSize temp2 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 char * kwnames[] = {
33812 (char *) "self",(char *) "sz", NULL
33813 };
33814
33815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33817 if (!SWIG_IsOK(res1)) {
33818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33819 }
33820 arg1 = reinterpret_cast< wxWindow * >(argp1);
33821 {
33822 arg2 = &temp2;
33823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33824 }
33825 {
33826 PyThreadState* __tstate = wxPyBeginAllowThreads();
33827 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33839 PyObject *resultobj = 0;
33840 wxWindow *arg1 = (wxWindow *) 0 ;
33841 wxPoint *arg2 = 0 ;
33842 wxPoint result;
33843 void *argp1 = 0 ;
33844 int res1 = 0 ;
33845 wxPoint temp2 ;
33846 PyObject * obj0 = 0 ;
33847 PyObject * obj1 = 0 ;
33848 char * kwnames[] = {
33849 (char *) "self",(char *) "pt", NULL
33850 };
33851
33852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33856 }
33857 arg1 = reinterpret_cast< wxWindow * >(argp1);
33858 {
33859 arg2 = &temp2;
33860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33861 }
33862 {
33863 PyThreadState* __tstate = wxPyBeginAllowThreads();
33864 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33865 wxPyEndAllowThreads(__tstate);
33866 if (PyErr_Occurred()) SWIG_fail;
33867 }
33868 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33869 return resultobj;
33870 fail:
33871 return NULL;
33872 }
33873
33874
33875 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33876 PyObject *resultobj = 0;
33877 wxWindow *arg1 = (wxWindow *) 0 ;
33878 wxSize *arg2 = 0 ;
33879 wxSize result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 wxSize temp2 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 char * kwnames[] = {
33886 (char *) "self",(char *) "sz", NULL
33887 };
33888
33889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33891 if (!SWIG_IsOK(res1)) {
33892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33893 }
33894 arg1 = reinterpret_cast< wxWindow * >(argp1);
33895 {
33896 arg2 = &temp2;
33897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33898 }
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33906 return resultobj;
33907 fail:
33908 return NULL;
33909 }
33910
33911
33912 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33913 PyObject *resultobj = 0;
33914 wxWindow *arg1 = (wxWindow *) 0 ;
33915 wxPoint *arg2 = 0 ;
33916 wxPoint result;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 wxPoint temp2 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "pt", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj = 0;
33951 wxWindow *arg1 = (wxWindow *) 0 ;
33952 wxSize *arg2 = 0 ;
33953 wxSize result;
33954 void *argp1 = 0 ;
33955 int res1 = 0 ;
33956 wxSize temp2 ;
33957 PyObject * obj0 = 0 ;
33958 PyObject * obj1 = 0 ;
33959 char * kwnames[] = {
33960 (char *) "self",(char *) "sz", NULL
33961 };
33962
33963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33967 }
33968 arg1 = reinterpret_cast< wxWindow * >(argp1);
33969 {
33970 arg2 = &temp2;
33971 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33972 }
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj = 0;
33988 wxWindow *arg1 = (wxWindow *) 0 ;
33989 int arg2 ;
33990 int arg3 ;
33991 void *argp1 = 0 ;
33992 int res1 = 0 ;
33993 int val2 ;
33994 int ecode2 = 0 ;
33995 int val3 ;
33996 int ecode3 = 0 ;
33997 PyObject * obj0 = 0 ;
33998 PyObject * obj1 = 0 ;
33999 PyObject * obj2 = 0 ;
34000 char * kwnames[] = {
34001 (char *) "self",(char *) "x",(char *) "y", NULL
34002 };
34003
34004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34006 if (!SWIG_IsOK(res1)) {
34007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34008 }
34009 arg1 = reinterpret_cast< wxWindow * >(argp1);
34010 ecode2 = SWIG_AsVal_int(obj1, &val2);
34011 if (!SWIG_IsOK(ecode2)) {
34012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34013 }
34014 arg2 = static_cast< int >(val2);
34015 ecode3 = SWIG_AsVal_int(obj2, &val3);
34016 if (!SWIG_IsOK(ecode3)) {
34017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34018 }
34019 arg3 = static_cast< int >(val3);
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 (arg1)->WarpPointer(arg2,arg3);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_Py_Void();
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 PyObject *swig_obj[1] ;
34039
34040 if (!args) SWIG_fail;
34041 swig_obj[0] = args;
34042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34043 if (!SWIG_IsOK(res1)) {
34044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34045 }
34046 arg1 = reinterpret_cast< wxWindow * >(argp1);
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 (arg1)->CaptureMouse();
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_Py_Void();
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061 PyObject *resultobj = 0;
34062 wxWindow *arg1 = (wxWindow *) 0 ;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 PyObject *swig_obj[1] ;
34066
34067 if (!args) SWIG_fail;
34068 swig_obj[0] = args;
34069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 PyThreadState* __tstate = wxPyBeginAllowThreads();
34076 (arg1)->ReleaseMouse();
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 resultobj = SWIG_Py_Void();
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34088 PyObject *resultobj = 0;
34089 wxWindow *result = 0 ;
34090
34091 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34092 {
34093 if (!wxPyCheckForApp()) SWIG_fail;
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 result = (wxWindow *)wxWindow::GetCapture();
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 {
34100 resultobj = wxPyMake_wxObject(result, 0);
34101 }
34102 return resultobj;
34103 fail:
34104 return NULL;
34105 }
34106
34107
34108 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34109 PyObject *resultobj = 0;
34110 wxWindow *arg1 = (wxWindow *) 0 ;
34111 bool result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 PyObject *swig_obj[1] ;
34115
34116 if (!args) SWIG_fail;
34117 swig_obj[0] = args;
34118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34121 }
34122 arg1 = reinterpret_cast< wxWindow * >(argp1);
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (bool)((wxWindow const *)arg1)->HasCapture();
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 {
34130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34131 }
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 bool arg2 = (bool) true ;
34142 wxRect *arg3 = (wxRect *) NULL ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 bool val2 ;
34146 int ecode2 = 0 ;
34147 void *argp3 = 0 ;
34148 int res3 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 PyObject * obj2 = 0 ;
34152 char * kwnames[] = {
34153 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34154 };
34155
34156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) 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_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34160 }
34161 arg1 = reinterpret_cast< wxWindow * >(argp1);
34162 if (obj1) {
34163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34164 if (!SWIG_IsOK(ecode2)) {
34165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34166 }
34167 arg2 = static_cast< bool >(val2);
34168 }
34169 if (obj2) {
34170 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34171 if (!SWIG_IsOK(res3)) {
34172 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34173 }
34174 arg3 = reinterpret_cast< wxRect * >(argp3);
34175 }
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxRect *arg2 = 0 ;
34193 bool arg3 = (bool) true ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 wxRect temp2 ;
34197 bool val3 ;
34198 int ecode3 = 0 ;
34199 PyObject * obj0 = 0 ;
34200 PyObject * obj1 = 0 ;
34201 PyObject * obj2 = 0 ;
34202 char * kwnames[] = {
34203 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34204 };
34205
34206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 arg2 = &temp2;
34214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34215 }
34216 if (obj2) {
34217 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34218 if (!SWIG_IsOK(ecode3)) {
34219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34220 }
34221 arg3 = static_cast< bool >(val3);
34222 }
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_Py_Void();
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 void *argp1 = 0 ;
34240 int res1 = 0 ;
34241 PyObject *swig_obj[1] ;
34242
34243 if (!args) SWIG_fail;
34244 swig_obj[0] = args;
34245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34246 if (!SWIG_IsOK(res1)) {
34247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34248 }
34249 arg1 = reinterpret_cast< wxWindow * >(argp1);
34250 {
34251 PyThreadState* __tstate = wxPyBeginAllowThreads();
34252 (arg1)->Update();
34253 wxPyEndAllowThreads(__tstate);
34254 if (PyErr_Occurred()) SWIG_fail;
34255 }
34256 resultobj = SWIG_Py_Void();
34257 return resultobj;
34258 fail:
34259 return NULL;
34260 }
34261
34262
34263 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34264 PyObject *resultobj = 0;
34265 wxWindow *arg1 = (wxWindow *) 0 ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 PyObject *swig_obj[1] ;
34269
34270 if (!args) SWIG_fail;
34271 swig_obj[0] = args;
34272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34273 if (!SWIG_IsOK(res1)) {
34274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34275 }
34276 arg1 = reinterpret_cast< wxWindow * >(argp1);
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 (arg1)->ClearBackground();
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 resultobj = SWIG_Py_Void();
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34291 PyObject *resultobj = 0;
34292 wxWindow *arg1 = (wxWindow *) 0 ;
34293 void *argp1 = 0 ;
34294 int res1 = 0 ;
34295 PyObject *swig_obj[1] ;
34296
34297 if (!args) SWIG_fail;
34298 swig_obj[0] = args;
34299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34300 if (!SWIG_IsOK(res1)) {
34301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34302 }
34303 arg1 = reinterpret_cast< wxWindow * >(argp1);
34304 {
34305 PyThreadState* __tstate = wxPyBeginAllowThreads();
34306 (arg1)->Freeze();
34307 wxPyEndAllowThreads(__tstate);
34308 if (PyErr_Occurred()) SWIG_fail;
34309 }
34310 resultobj = SWIG_Py_Void();
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->Thaw();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 resultobj = SWIG_Py_Void();
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34345 PyObject *resultobj = 0;
34346 wxWindow *arg1 = (wxWindow *) 0 ;
34347 wxDC *arg2 = 0 ;
34348 void *argp1 = 0 ;
34349 int res1 = 0 ;
34350 void *argp2 = 0 ;
34351 int res2 = 0 ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 char * kwnames[] = {
34355 (char *) "self",(char *) "dc", NULL
34356 };
34357
34358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34365 if (!SWIG_IsOK(res2)) {
34366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34367 }
34368 if (!argp2) {
34369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34370 }
34371 arg2 = reinterpret_cast< wxDC * >(argp2);
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->PrepareDC(*arg2);
34375 wxPyEndAllowThreads(__tstate);
34376 if (PyErr_Occurred()) SWIG_fail;
34377 }
34378 resultobj = SWIG_Py_Void();
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxWindow *arg1 = (wxWindow *) 0 ;
34388 wxRegion *result = 0 ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 {
34403 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34404 result = (wxRegion *) &_result_ref;
34405 }
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 wxRect result;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 PyObject *swig_obj[1] ;
34423
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34429 }
34430 arg1 = reinterpret_cast< wxWindow * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 int arg2 ;
34448 int arg3 ;
34449 int arg4 = (int) 1 ;
34450 int arg5 = (int) 1 ;
34451 bool result;
34452 void *argp1 = 0 ;
34453 int res1 = 0 ;
34454 int val2 ;
34455 int ecode2 = 0 ;
34456 int val3 ;
34457 int ecode3 = 0 ;
34458 int val4 ;
34459 int ecode4 = 0 ;
34460 int val5 ;
34461 int ecode5 = 0 ;
34462 PyObject * obj0 = 0 ;
34463 PyObject * obj1 = 0 ;
34464 PyObject * obj2 = 0 ;
34465 PyObject * obj3 = 0 ;
34466 PyObject * obj4 = 0 ;
34467 char * kwnames[] = {
34468 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34469 };
34470
34471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 ecode2 = SWIG_AsVal_int(obj1, &val2);
34478 if (!SWIG_IsOK(ecode2)) {
34479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34480 }
34481 arg2 = static_cast< int >(val2);
34482 ecode3 = SWIG_AsVal_int(obj2, &val3);
34483 if (!SWIG_IsOK(ecode3)) {
34484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34485 }
34486 arg3 = static_cast< int >(val3);
34487 if (obj3) {
34488 ecode4 = SWIG_AsVal_int(obj3, &val4);
34489 if (!SWIG_IsOK(ecode4)) {
34490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34491 }
34492 arg4 = static_cast< int >(val4);
34493 }
34494 if (obj4) {
34495 ecode5 = SWIG_AsVal_int(obj4, &val5);
34496 if (!SWIG_IsOK(ecode5)) {
34497 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34498 }
34499 arg5 = static_cast< int >(val5);
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 {
34508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34509 }
34510 return resultobj;
34511 fail:
34512 return NULL;
34513 }
34514
34515
34516 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34517 PyObject *resultobj = 0;
34518 wxWindow *arg1 = (wxWindow *) 0 ;
34519 wxPoint *arg2 = 0 ;
34520 bool result;
34521 void *argp1 = 0 ;
34522 int res1 = 0 ;
34523 wxPoint temp2 ;
34524 PyObject * obj0 = 0 ;
34525 PyObject * obj1 = 0 ;
34526 char * kwnames[] = {
34527 (char *) "self",(char *) "pt", NULL
34528 };
34529
34530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34532 if (!SWIG_IsOK(res1)) {
34533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34534 }
34535 arg1 = reinterpret_cast< wxWindow * >(argp1);
34536 {
34537 arg2 = &temp2;
34538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34539 }
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 {
34547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34548 }
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj = 0;
34557 wxWindow *arg1 = (wxWindow *) 0 ;
34558 wxRect *arg2 = 0 ;
34559 bool result;
34560 void *argp1 = 0 ;
34561 int res1 = 0 ;
34562 wxRect temp2 ;
34563 PyObject * obj0 = 0 ;
34564 PyObject * obj1 = 0 ;
34565 char * kwnames[] = {
34566 (char *) "self",(char *) "rect", NULL
34567 };
34568
34569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34571 if (!SWIG_IsOK(res1)) {
34572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34573 }
34574 arg1 = reinterpret_cast< wxWindow * >(argp1);
34575 {
34576 arg2 = &temp2;
34577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34578 }
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 {
34586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34587 }
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 SwigValueWrapper<wxVisualAttributes > result;
34598 void *argp1 = 0 ;
34599 int res1 = 0 ;
34600 PyObject *swig_obj[1] ;
34601
34602 if (!args) SWIG_fail;
34603 swig_obj[0] = args;
34604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34612 wxPyEndAllowThreads(__tstate);
34613 if (PyErr_Occurred()) SWIG_fail;
34614 }
34615 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34623 PyObject *resultobj = 0;
34624 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34625 SwigValueWrapper<wxVisualAttributes > result;
34626 int val1 ;
34627 int ecode1 = 0 ;
34628 PyObject * obj0 = 0 ;
34629 char * kwnames[] = {
34630 (char *) "variant", NULL
34631 };
34632
34633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34634 if (obj0) {
34635 ecode1 = SWIG_AsVal_int(obj0, &val1);
34636 if (!SWIG_IsOK(ecode1)) {
34637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34638 }
34639 arg1 = static_cast< wxWindowVariant >(val1);
34640 }
34641 {
34642 if (!wxPyCheckForApp()) SWIG_fail;
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 result = wxWindow::GetClassDefaultAttributes(arg1);
34645 wxPyEndAllowThreads(__tstate);
34646 if (PyErr_Occurred()) SWIG_fail;
34647 }
34648 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 wxColour *arg2 = 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 wxColour temp2 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 char * kwnames[] = {
34666 (char *) "self",(char *) "colour", NULL
34667 };
34668
34669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 arg2 = &temp2;
34677 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxColour *arg2 = 0 ;
34698 void *argp1 = 0 ;
34699 int res1 = 0 ;
34700 wxColour temp2 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char * kwnames[] = {
34704 (char *) "self",(char *) "colour", NULL
34705 };
34706
34707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34709 if (!SWIG_IsOK(res1)) {
34710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34711 }
34712 arg1 = reinterpret_cast< wxWindow * >(argp1);
34713 {
34714 arg2 = &temp2;
34715 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34716 }
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 wxColour *arg2 = 0 ;
34734 bool result;
34735 void *argp1 = 0 ;
34736 int res1 = 0 ;
34737 wxColour temp2 ;
34738 PyObject * obj0 = 0 ;
34739 PyObject * obj1 = 0 ;
34740 char * kwnames[] = {
34741 (char *) "self",(char *) "colour", NULL
34742 };
34743
34744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34748 }
34749 arg1 = reinterpret_cast< wxWindow * >(argp1);
34750 {
34751 arg2 = &temp2;
34752 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34753 }
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 {
34761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34762 }
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 wxColour *arg2 = 0 ;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 wxColour temp2 ;
34776 PyObject * obj0 = 0 ;
34777 PyObject * obj1 = 0 ;
34778 char * kwnames[] = {
34779 (char *) "self",(char *) "colour", NULL
34780 };
34781
34782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 arg2 = &temp2;
34790 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34791 }
34792 {
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 resultobj = SWIG_Py_Void();
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34806 PyObject *resultobj = 0;
34807 wxWindow *arg1 = (wxWindow *) 0 ;
34808 wxColour result;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 PyObject *swig_obj[1] ;
34812
34813 if (!args) SWIG_fail;
34814 swig_obj[0] = args;
34815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34816 if (!SWIG_IsOK(res1)) {
34817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34818 }
34819 arg1 = reinterpret_cast< wxWindow * >(argp1);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxColour result;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 PyObject *swig_obj[1] ;
34840
34841 if (!args) SWIG_fail;
34842 swig_obj[0] = args;
34843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = ((wxWindow const *)arg1)->GetForegroundColour();
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 bool result;
34865 void *argp1 = 0 ;
34866 int res1 = 0 ;
34867 PyObject *swig_obj[1] ;
34868
34869 if (!args) SWIG_fail;
34870 swig_obj[0] = args;
34871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 bool result;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 PyObject *swig_obj[1] ;
34898
34899 if (!args) SWIG_fail;
34900 swig_obj[0] = args;
34901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34902 if (!SWIG_IsOK(res1)) {
34903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34904 }
34905 arg1 = reinterpret_cast< wxWindow * >(argp1);
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 {
34913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34914 }
34915 return resultobj;
34916 fail:
34917 return NULL;
34918 }
34919
34920
34921 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34922 PyObject *resultobj = 0;
34923 wxWindow *arg1 = (wxWindow *) 0 ;
34924 wxBackgroundStyle arg2 ;
34925 bool result;
34926 void *argp1 = 0 ;
34927 int res1 = 0 ;
34928 int val2 ;
34929 int ecode2 = 0 ;
34930 PyObject * obj0 = 0 ;
34931 PyObject * obj1 = 0 ;
34932 char * kwnames[] = {
34933 (char *) "self",(char *) "style", NULL
34934 };
34935
34936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 ecode2 = SWIG_AsVal_int(obj1, &val2);
34943 if (!SWIG_IsOK(ecode2)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34945 }
34946 arg2 = static_cast< wxBackgroundStyle >(val2);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = (bool)(arg1)->SetBackgroundStyle(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_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34963 PyObject *resultobj = 0;
34964 wxWindow *arg1 = (wxWindow *) 0 ;
34965 wxBackgroundStyle result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 PyObject *swig_obj[1] ;
34969
34970 if (!args) SWIG_fail;
34971 swig_obj[0] = args;
34972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 resultobj = SWIG_From_int(static_cast< int >(result));
34984 return resultobj;
34985 fail:
34986 return NULL;
34987 }
34988
34989
34990 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34991 PyObject *resultobj = 0;
34992 wxWindow *arg1 = (wxWindow *) 0 ;
34993 bool result;
34994 void *argp1 = 0 ;
34995 int res1 = 0 ;
34996 PyObject *swig_obj[1] ;
34997
34998 if (!args) SWIG_fail;
34999 swig_obj[0] = args;
35000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35003 }
35004 arg1 = reinterpret_cast< wxWindow * >(argp1);
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 result = (bool)(arg1)->HasTransparentBackground();
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 {
35012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35013 }
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj = 0;
35022 wxWindow *arg1 = (wxWindow *) 0 ;
35023 wxCursor *arg2 = 0 ;
35024 bool result;
35025 void *argp1 = 0 ;
35026 int res1 = 0 ;
35027 void *argp2 = 0 ;
35028 int res2 = 0 ;
35029 PyObject * obj0 = 0 ;
35030 PyObject * obj1 = 0 ;
35031 char * kwnames[] = {
35032 (char *) "self",(char *) "cursor", NULL
35033 };
35034
35035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35037 if (!SWIG_IsOK(res1)) {
35038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35039 }
35040 arg1 = reinterpret_cast< wxWindow * >(argp1);
35041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35042 if (!SWIG_IsOK(res2)) {
35043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35044 }
35045 if (!argp2) {
35046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35047 }
35048 arg2 = reinterpret_cast< wxCursor * >(argp2);
35049 {
35050 PyThreadState* __tstate = wxPyBeginAllowThreads();
35051 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 {
35056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35057 }
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35065 PyObject *resultobj = 0;
35066 wxWindow *arg1 = (wxWindow *) 0 ;
35067 wxCursor result;
35068 void *argp1 = 0 ;
35069 int res1 = 0 ;
35070 PyObject *swig_obj[1] ;
35071
35072 if (!args) SWIG_fail;
35073 swig_obj[0] = args;
35074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35077 }
35078 arg1 = reinterpret_cast< wxWindow * >(argp1);
35079 {
35080 PyThreadState* __tstate = wxPyBeginAllowThreads();
35081 result = (arg1)->GetCursor();
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 wxWindow *arg1 = (wxWindow *) 0 ;
35095 wxFont *arg2 = 0 ;
35096 bool result;
35097 void *argp1 = 0 ;
35098 int res1 = 0 ;
35099 void *argp2 = 0 ;
35100 int res2 = 0 ;
35101 PyObject * obj0 = 0 ;
35102 PyObject * obj1 = 0 ;
35103 char * kwnames[] = {
35104 (char *) "self",(char *) "font", NULL
35105 };
35106
35107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35109 if (!SWIG_IsOK(res1)) {
35110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35111 }
35112 arg1 = reinterpret_cast< wxWindow * >(argp1);
35113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35114 if (!SWIG_IsOK(res2)) {
35115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35116 }
35117 if (!argp2) {
35118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35119 }
35120 arg2 = reinterpret_cast< wxFont * >(argp2);
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35124 wxPyEndAllowThreads(__tstate);
35125 if (PyErr_Occurred()) SWIG_fail;
35126 }
35127 {
35128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35129 }
35130 return resultobj;
35131 fail:
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35137 PyObject *resultobj = 0;
35138 wxWindow *arg1 = (wxWindow *) 0 ;
35139 wxFont *arg2 = 0 ;
35140 void *argp1 = 0 ;
35141 int res1 = 0 ;
35142 void *argp2 = 0 ;
35143 int res2 = 0 ;
35144 PyObject * obj0 = 0 ;
35145 PyObject * obj1 = 0 ;
35146 char * kwnames[] = {
35147 (char *) "self",(char *) "font", NULL
35148 };
35149
35150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35157 if (!SWIG_IsOK(res2)) {
35158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35159 }
35160 if (!argp2) {
35161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35162 }
35163 arg2 = reinterpret_cast< wxFont * >(argp2);
35164 {
35165 PyThreadState* __tstate = wxPyBeginAllowThreads();
35166 (arg1)->SetOwnFont((wxFont const &)*arg2);
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 resultobj = SWIG_Py_Void();
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35178 PyObject *resultobj = 0;
35179 wxWindow *arg1 = (wxWindow *) 0 ;
35180 wxFont result;
35181 void *argp1 = 0 ;
35182 int res1 = 0 ;
35183 PyObject *swig_obj[1] ;
35184
35185 if (!args) SWIG_fail;
35186 swig_obj[0] = args;
35187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = (arg1)->GetFont();
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35199 return resultobj;
35200 fail:
35201 return NULL;
35202 }
35203
35204
35205 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35206 PyObject *resultobj = 0;
35207 wxWindow *arg1 = (wxWindow *) 0 ;
35208 wxCaret *arg2 = (wxCaret *) 0 ;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 int res2 = 0 ;
35212 PyObject * obj0 = 0 ;
35213 PyObject * obj1 = 0 ;
35214 char * kwnames[] = {
35215 (char *) "self",(char *) "caret", NULL
35216 };
35217
35218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35222 }
35223 arg1 = reinterpret_cast< wxWindow * >(argp1);
35224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35225 if (!SWIG_IsOK(res2)) {
35226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35227 }
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 (arg1)->SetCaret(arg2);
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 resultobj = SWIG_Py_Void();
35235 return resultobj;
35236 fail:
35237 return NULL;
35238 }
35239
35240
35241 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35242 PyObject *resultobj = 0;
35243 wxWindow *arg1 = (wxWindow *) 0 ;
35244 wxCaret *result = 0 ;
35245 void *argp1 = 0 ;
35246 int res1 = 0 ;
35247 PyObject *swig_obj[1] ;
35248
35249 if (!args) SWIG_fail;
35250 swig_obj[0] = args;
35251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35263 return resultobj;
35264 fail:
35265 return NULL;
35266 }
35267
35268
35269 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35270 PyObject *resultobj = 0;
35271 wxWindow *arg1 = (wxWindow *) 0 ;
35272 int result;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 PyObject *swig_obj[1] ;
35276
35277 if (!args) SWIG_fail;
35278 swig_obj[0] = args;
35279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35280 if (!SWIG_IsOK(res1)) {
35281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35282 }
35283 arg1 = reinterpret_cast< wxWindow * >(argp1);
35284 {
35285 PyThreadState* __tstate = wxPyBeginAllowThreads();
35286 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 resultobj = SWIG_From_int(static_cast< int >(result));
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35298 PyObject *resultobj = 0;
35299 wxWindow *arg1 = (wxWindow *) 0 ;
35300 int result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 PyObject *swig_obj[1] ;
35304
35305 if (!args) SWIG_fail;
35306 swig_obj[0] = args;
35307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35310 }
35311 arg1 = reinterpret_cast< wxWindow * >(argp1);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = SWIG_From_int(static_cast< int >(result));
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35326 PyObject *resultobj = 0;
35327 wxWindow *arg1 = (wxWindow *) 0 ;
35328 wxString *arg2 = 0 ;
35329 int *arg3 = (int *) 0 ;
35330 int *arg4 = (int *) 0 ;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 bool temp2 = false ;
35334 int temp3 ;
35335 int res3 = SWIG_TMPOBJ ;
35336 int temp4 ;
35337 int res4 = SWIG_TMPOBJ ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "string", NULL
35342 };
35343
35344 arg3 = &temp3;
35345 arg4 = &temp4;
35346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35348 if (!SWIG_IsOK(res1)) {
35349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35350 }
35351 arg1 = reinterpret_cast< wxWindow * >(argp1);
35352 {
35353 arg2 = wxString_in_helper(obj1);
35354 if (arg2 == NULL) SWIG_fail;
35355 temp2 = true;
35356 }
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_Py_Void();
35364 if (SWIG_IsTmpObj(res3)) {
35365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35366 } else {
35367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35369 }
35370 if (SWIG_IsTmpObj(res4)) {
35371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35372 } else {
35373 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35375 }
35376 {
35377 if (temp2)
35378 delete arg2;
35379 }
35380 return resultobj;
35381 fail:
35382 {
35383 if (temp2)
35384 delete arg2;
35385 }
35386 return NULL;
35387 }
35388
35389
35390 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj = 0;
35392 wxWindow *arg1 = (wxWindow *) 0 ;
35393 wxString *arg2 = 0 ;
35394 int *arg3 = (int *) 0 ;
35395 int *arg4 = (int *) 0 ;
35396 int *arg5 = (int *) 0 ;
35397 int *arg6 = (int *) 0 ;
35398 wxFont *arg7 = (wxFont *) NULL ;
35399 void *argp1 = 0 ;
35400 int res1 = 0 ;
35401 bool temp2 = false ;
35402 int temp3 ;
35403 int res3 = SWIG_TMPOBJ ;
35404 int temp4 ;
35405 int res4 = SWIG_TMPOBJ ;
35406 int temp5 ;
35407 int res5 = SWIG_TMPOBJ ;
35408 int temp6 ;
35409 int res6 = SWIG_TMPOBJ ;
35410 void *argp7 = 0 ;
35411 int res7 = 0 ;
35412 PyObject * obj0 = 0 ;
35413 PyObject * obj1 = 0 ;
35414 PyObject * obj2 = 0 ;
35415 char * kwnames[] = {
35416 (char *) "self",(char *) "string",(char *) "font", NULL
35417 };
35418
35419 arg3 = &temp3;
35420 arg4 = &temp4;
35421 arg5 = &temp5;
35422 arg6 = &temp6;
35423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35425 if (!SWIG_IsOK(res1)) {
35426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35427 }
35428 arg1 = reinterpret_cast< wxWindow * >(argp1);
35429 {
35430 arg2 = wxString_in_helper(obj1);
35431 if (arg2 == NULL) SWIG_fail;
35432 temp2 = true;
35433 }
35434 if (obj2) {
35435 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35436 if (!SWIG_IsOK(res7)) {
35437 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35438 }
35439 arg7 = reinterpret_cast< wxFont * >(argp7);
35440 }
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 resultobj = SWIG_Py_Void();
35448 if (SWIG_IsTmpObj(res3)) {
35449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35450 } else {
35451 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35453 }
35454 if (SWIG_IsTmpObj(res4)) {
35455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35456 } else {
35457 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35459 }
35460 if (SWIG_IsTmpObj(res5)) {
35461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35462 } else {
35463 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35465 }
35466 if (SWIG_IsTmpObj(res6)) {
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35468 } else {
35469 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35471 }
35472 {
35473 if (temp2)
35474 delete arg2;
35475 }
35476 return resultobj;
35477 fail:
35478 {
35479 if (temp2)
35480 delete arg2;
35481 }
35482 return NULL;
35483 }
35484
35485
35486 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35487 PyObject *resultobj = 0;
35488 wxWindow *arg1 = (wxWindow *) 0 ;
35489 int *arg2 = (int *) 0 ;
35490 int *arg3 = (int *) 0 ;
35491 void *argp1 = 0 ;
35492 int res1 = 0 ;
35493 int temp2 ;
35494 int res2 = 0 ;
35495 int temp3 ;
35496 int res3 = 0 ;
35497 PyObject * obj0 = 0 ;
35498 PyObject * obj1 = 0 ;
35499 PyObject * obj2 = 0 ;
35500 char * kwnames[] = {
35501 (char *) "self",(char *) "x",(char *) "y", NULL
35502 };
35503
35504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35506 if (!SWIG_IsOK(res1)) {
35507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35508 }
35509 arg1 = reinterpret_cast< wxWindow * >(argp1);
35510 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35511 int val;
35512 int ecode = SWIG_AsVal_int(obj1, &val);
35513 if (!SWIG_IsOK(ecode)) {
35514 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35515 }
35516 temp2 = static_cast< int >(val);
35517 arg2 = &temp2;
35518 res2 = SWIG_AddTmpMask(ecode);
35519 }
35520 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35521 int val;
35522 int ecode = SWIG_AsVal_int(obj2, &val);
35523 if (!SWIG_IsOK(ecode)) {
35524 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35525 }
35526 temp3 = static_cast< int >(val);
35527 arg3 = &temp3;
35528 res3 = SWIG_AddTmpMask(ecode);
35529 }
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 resultobj = SWIG_Py_Void();
35537 if (SWIG_IsTmpObj(res2)) {
35538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35539 } else {
35540 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35542 }
35543 if (SWIG_IsTmpObj(res3)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35548 }
35549 return resultobj;
35550 fail:
35551 return NULL;
35552 }
35553
35554
35555 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35556 PyObject *resultobj = 0;
35557 wxWindow *arg1 = (wxWindow *) 0 ;
35558 int *arg2 = (int *) 0 ;
35559 int *arg3 = (int *) 0 ;
35560 void *argp1 = 0 ;
35561 int res1 = 0 ;
35562 int temp2 ;
35563 int res2 = 0 ;
35564 int temp3 ;
35565 int res3 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 PyObject * obj2 = 0 ;
35569 char * kwnames[] = {
35570 (char *) "self",(char *) "x",(char *) "y", NULL
35571 };
35572
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35580 int val;
35581 int ecode = SWIG_AsVal_int(obj1, &val);
35582 if (!SWIG_IsOK(ecode)) {
35583 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35584 }
35585 temp2 = static_cast< int >(val);
35586 arg2 = &temp2;
35587 res2 = SWIG_AddTmpMask(ecode);
35588 }
35589 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35590 int val;
35591 int ecode = SWIG_AsVal_int(obj2, &val);
35592 if (!SWIG_IsOK(ecode)) {
35593 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35594 }
35595 temp3 = static_cast< int >(val);
35596 arg3 = &temp3;
35597 res3 = SWIG_AddTmpMask(ecode);
35598 }
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_Py_Void();
35606 if (SWIG_IsTmpObj(res2)) {
35607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35608 } else {
35609 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35611 }
35612 if (SWIG_IsTmpObj(res3)) {
35613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35614 } else {
35615 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35617 }
35618 return resultobj;
35619 fail:
35620 return NULL;
35621 }
35622
35623
35624 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35625 PyObject *resultobj = 0;
35626 wxWindow *arg1 = (wxWindow *) 0 ;
35627 wxPoint *arg2 = 0 ;
35628 wxPoint result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 wxPoint temp2 ;
35632 PyObject * obj0 = 0 ;
35633 PyObject * obj1 = 0 ;
35634 char * kwnames[] = {
35635 (char *) "self",(char *) "pt", NULL
35636 };
35637
35638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35640 if (!SWIG_IsOK(res1)) {
35641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35642 }
35643 arg1 = reinterpret_cast< wxWindow * >(argp1);
35644 {
35645 arg2 = &temp2;
35646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35647 }
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 wxPoint *arg2 = 0 ;
35665 wxPoint result;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 wxPoint temp2 ;
35669 PyObject * obj0 = 0 ;
35670 PyObject * obj1 = 0 ;
35671 char * kwnames[] = {
35672 (char *) "self",(char *) "pt", NULL
35673 };
35674
35675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35677 if (!SWIG_IsOK(res1)) {
35678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35679 }
35680 arg1 = reinterpret_cast< wxWindow * >(argp1);
35681 {
35682 arg2 = &temp2;
35683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35684 }
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj = 0;
35700 wxWindow *arg1 = (wxWindow *) 0 ;
35701 int arg2 ;
35702 int arg3 ;
35703 wxHitTest result;
35704 void *argp1 = 0 ;
35705 int res1 = 0 ;
35706 int val2 ;
35707 int ecode2 = 0 ;
35708 int val3 ;
35709 int ecode3 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 PyObject * obj2 = 0 ;
35713 char * kwnames[] = {
35714 (char *) "self",(char *) "x",(char *) "y", NULL
35715 };
35716
35717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35721 }
35722 arg1 = reinterpret_cast< wxWindow * >(argp1);
35723 ecode2 = SWIG_AsVal_int(obj1, &val2);
35724 if (!SWIG_IsOK(ecode2)) {
35725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35726 }
35727 arg2 = static_cast< int >(val2);
35728 ecode3 = SWIG_AsVal_int(obj2, &val3);
35729 if (!SWIG_IsOK(ecode3)) {
35730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35731 }
35732 arg3 = static_cast< int >(val3);
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35736 wxPyEndAllowThreads(__tstate);
35737 if (PyErr_Occurred()) SWIG_fail;
35738 }
35739 resultobj = SWIG_From_int(static_cast< int >(result));
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35747 PyObject *resultobj = 0;
35748 wxWindow *arg1 = (wxWindow *) 0 ;
35749 wxPoint *arg2 = 0 ;
35750 wxHitTest result;
35751 void *argp1 = 0 ;
35752 int res1 = 0 ;
35753 wxPoint temp2 ;
35754 PyObject * obj0 = 0 ;
35755 PyObject * obj1 = 0 ;
35756 char * kwnames[] = {
35757 (char *) "self",(char *) "pt", NULL
35758 };
35759
35760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35762 if (!SWIG_IsOK(res1)) {
35763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35764 }
35765 arg1 = reinterpret_cast< wxWindow * >(argp1);
35766 {
35767 arg2 = &temp2;
35768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35769 }
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35773 wxPyEndAllowThreads(__tstate);
35774 if (PyErr_Occurred()) SWIG_fail;
35775 }
35776 resultobj = SWIG_From_int(static_cast< int >(result));
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35784 PyObject *resultobj = 0;
35785 wxWindow *arg1 = (wxWindow *) 0 ;
35786 long arg2 ;
35787 wxBorder result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 long val2 ;
35791 int ecode2 = 0 ;
35792
35793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35800 if (!SWIG_IsOK(ecode2)) {
35801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35802 }
35803 arg2 = static_cast< long >(val2);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 resultobj = SWIG_From_int(static_cast< int >(result));
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 wxBorder result;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823
35824 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35828 }
35829 arg1 = reinterpret_cast< wxWindow * >(argp1);
35830 {
35831 PyThreadState* __tstate = wxPyBeginAllowThreads();
35832 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 resultobj = SWIG_From_int(static_cast< int >(result));
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35844 int argc;
35845 PyObject *argv[3];
35846
35847 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35848 --argc;
35849 if (argc == 1) {
35850 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35851 }
35852 if (argc == 2) {
35853 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35854 }
35855
35856 fail:
35857 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35858 return NULL;
35859 }
35860
35861
35862 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35863 PyObject *resultobj = 0;
35864 wxWindow *arg1 = (wxWindow *) 0 ;
35865 long arg2 = (long) wxUPDATE_UI_NONE ;
35866 void *argp1 = 0 ;
35867 int res1 = 0 ;
35868 long val2 ;
35869 int ecode2 = 0 ;
35870 PyObject * obj0 = 0 ;
35871 PyObject * obj1 = 0 ;
35872 char * kwnames[] = {
35873 (char *) "self",(char *) "flags", NULL
35874 };
35875
35876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35878 if (!SWIG_IsOK(res1)) {
35879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35880 }
35881 arg1 = reinterpret_cast< wxWindow * >(argp1);
35882 if (obj1) {
35883 ecode2 = SWIG_AsVal_long(obj1, &val2);
35884 if (!SWIG_IsOK(ecode2)) {
35885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35886 }
35887 arg2 = static_cast< long >(val2);
35888 }
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 (arg1)->UpdateWindowUI(arg2);
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 resultobj = SWIG_Py_Void();
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35903 PyObject *resultobj = 0;
35904 wxWindow *arg1 = (wxWindow *) 0 ;
35905 wxMenu *arg2 = (wxMenu *) 0 ;
35906 int arg3 = (int) -1 ;
35907 int arg4 = (int) -1 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 void *argp2 = 0 ;
35912 int res2 = 0 ;
35913 int val3 ;
35914 int ecode3 = 0 ;
35915 int val4 ;
35916 int ecode4 = 0 ;
35917 PyObject * obj0 = 0 ;
35918 PyObject * obj1 = 0 ;
35919 PyObject * obj2 = 0 ;
35920 PyObject * obj3 = 0 ;
35921 char * kwnames[] = {
35922 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35923 };
35924
35925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35927 if (!SWIG_IsOK(res1)) {
35928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35929 }
35930 arg1 = reinterpret_cast< wxWindow * >(argp1);
35931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35932 if (!SWIG_IsOK(res2)) {
35933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35934 }
35935 arg2 = reinterpret_cast< wxMenu * >(argp2);
35936 if (obj2) {
35937 ecode3 = SWIG_AsVal_int(obj2, &val3);
35938 if (!SWIG_IsOK(ecode3)) {
35939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35940 }
35941 arg3 = static_cast< int >(val3);
35942 }
35943 if (obj3) {
35944 ecode4 = SWIG_AsVal_int(obj3, &val4);
35945 if (!SWIG_IsOK(ecode4)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35947 }
35948 arg4 = static_cast< int >(val4);
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 {
35957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35958 }
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj = 0;
35967 wxWindow *arg1 = (wxWindow *) 0 ;
35968 wxMenu *arg2 = (wxMenu *) 0 ;
35969 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35970 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35971 bool result;
35972 void *argp1 = 0 ;
35973 int res1 = 0 ;
35974 void *argp2 = 0 ;
35975 int res2 = 0 ;
35976 wxPoint temp3 ;
35977 PyObject * obj0 = 0 ;
35978 PyObject * obj1 = 0 ;
35979 PyObject * obj2 = 0 ;
35980 char * kwnames[] = {
35981 (char *) "self",(char *) "menu",(char *) "pos", NULL
35982 };
35983
35984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35986 if (!SWIG_IsOK(res1)) {
35987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35988 }
35989 arg1 = reinterpret_cast< wxWindow * >(argp1);
35990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35991 if (!SWIG_IsOK(res2)) {
35992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35993 }
35994 arg2 = reinterpret_cast< wxMenu * >(argp2);
35995 if (obj2) {
35996 {
35997 arg3 = &temp3;
35998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35999 }
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 {
36008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36009 }
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 long result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (long)wxWindow_GetHandle(arg1);
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 resultobj = SWIG_From_long(static_cast< long >(result));
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 long arg2 ;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 long val2 ;
36051 int ecode2 = 0 ;
36052 PyObject * obj0 = 0 ;
36053 PyObject * obj1 = 0 ;
36054 char * kwnames[] = {
36055 (char *) "self",(char *) "handle", NULL
36056 };
36057
36058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36062 }
36063 arg1 = reinterpret_cast< wxWindow * >(argp1);
36064 ecode2 = SWIG_AsVal_long(obj1, &val2);
36065 if (!SWIG_IsOK(ecode2)) {
36066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36067 }
36068 arg2 = static_cast< long >(val2);
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 wxWindow_AssociateHandle(arg1,arg2);
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_Py_Void();
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 void *argp1 = 0 ;
36086 int res1 = 0 ;
36087 PyObject *swig_obj[1] ;
36088
36089 if (!args) SWIG_fail;
36090 swig_obj[0] = args;
36091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36094 }
36095 arg1 = reinterpret_cast< wxWindow * >(argp1);
36096 {
36097 PyThreadState* __tstate = wxPyBeginAllowThreads();
36098 (arg1)->DissociateHandle();
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 resultobj = SWIG_Py_Void();
36103 return resultobj;
36104 fail:
36105 return NULL;
36106 }
36107
36108
36109 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36110 PyObject *resultobj = 0;
36111 wxWindow *arg1 = (wxWindow *) 0 ;
36112 wxPaintEvent *arg2 = 0 ;
36113 void *argp1 = 0 ;
36114 int res1 = 0 ;
36115 void *argp2 = 0 ;
36116 int res2 = 0 ;
36117 PyObject * obj0 = 0 ;
36118 PyObject * obj1 = 0 ;
36119 char * kwnames[] = {
36120 (char *) "self",(char *) "event", NULL
36121 };
36122
36123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36125 if (!SWIG_IsOK(res1)) {
36126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36127 }
36128 arg1 = reinterpret_cast< wxWindow * >(argp1);
36129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36130 if (!SWIG_IsOK(res2)) {
36131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36132 }
36133 if (!argp2) {
36134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36135 }
36136 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 (arg1)->OnPaint(*arg2);
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 resultobj = SWIG_Py_Void();
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36151 PyObject *resultobj = 0;
36152 wxWindow *arg1 = (wxWindow *) 0 ;
36153 int arg2 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 int val2 ;
36158 int ecode2 = 0 ;
36159 PyObject * obj0 = 0 ;
36160 PyObject * obj1 = 0 ;
36161 char * kwnames[] = {
36162 (char *) "self",(char *) "orient", NULL
36163 };
36164
36165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36167 if (!SWIG_IsOK(res1)) {
36168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36169 }
36170 arg1 = reinterpret_cast< wxWindow * >(argp1);
36171 ecode2 = SWIG_AsVal_int(obj1, &val2);
36172 if (!SWIG_IsOK(ecode2)) {
36173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36174 }
36175 arg2 = static_cast< int >(val2);
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 {
36183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36184 }
36185 return resultobj;
36186 fail:
36187 return NULL;
36188 }
36189
36190
36191 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj = 0;
36193 wxWindow *arg1 = (wxWindow *) 0 ;
36194 int arg2 ;
36195 int arg3 ;
36196 int arg4 ;
36197 int arg5 ;
36198 bool arg6 = (bool) true ;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 int val2 ;
36202 int ecode2 = 0 ;
36203 int val3 ;
36204 int ecode3 = 0 ;
36205 int val4 ;
36206 int ecode4 = 0 ;
36207 int val5 ;
36208 int ecode5 = 0 ;
36209 bool val6 ;
36210 int ecode6 = 0 ;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 PyObject * obj2 = 0 ;
36214 PyObject * obj3 = 0 ;
36215 PyObject * obj4 = 0 ;
36216 PyObject * obj5 = 0 ;
36217 char * kwnames[] = {
36218 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36219 };
36220
36221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36223 if (!SWIG_IsOK(res1)) {
36224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36225 }
36226 arg1 = reinterpret_cast< wxWindow * >(argp1);
36227 ecode2 = SWIG_AsVal_int(obj1, &val2);
36228 if (!SWIG_IsOK(ecode2)) {
36229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36230 }
36231 arg2 = static_cast< int >(val2);
36232 ecode3 = SWIG_AsVal_int(obj2, &val3);
36233 if (!SWIG_IsOK(ecode3)) {
36234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36235 }
36236 arg3 = static_cast< int >(val3);
36237 ecode4 = SWIG_AsVal_int(obj3, &val4);
36238 if (!SWIG_IsOK(ecode4)) {
36239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36240 }
36241 arg4 = static_cast< int >(val4);
36242 ecode5 = SWIG_AsVal_int(obj4, &val5);
36243 if (!SWIG_IsOK(ecode5)) {
36244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36245 }
36246 arg5 = static_cast< int >(val5);
36247 if (obj5) {
36248 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36249 if (!SWIG_IsOK(ecode6)) {
36250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36251 }
36252 arg6 = static_cast< bool >(val6);
36253 }
36254 {
36255 PyThreadState* __tstate = wxPyBeginAllowThreads();
36256 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36257 wxPyEndAllowThreads(__tstate);
36258 if (PyErr_Occurred()) SWIG_fail;
36259 }
36260 resultobj = SWIG_Py_Void();
36261 return resultobj;
36262 fail:
36263 return NULL;
36264 }
36265
36266
36267 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36268 PyObject *resultobj = 0;
36269 wxWindow *arg1 = (wxWindow *) 0 ;
36270 int arg2 ;
36271 int arg3 ;
36272 bool arg4 = (bool) true ;
36273 void *argp1 = 0 ;
36274 int res1 = 0 ;
36275 int val2 ;
36276 int ecode2 = 0 ;
36277 int val3 ;
36278 int ecode3 = 0 ;
36279 bool val4 ;
36280 int ecode4 = 0 ;
36281 PyObject * obj0 = 0 ;
36282 PyObject * obj1 = 0 ;
36283 PyObject * obj2 = 0 ;
36284 PyObject * obj3 = 0 ;
36285 char * kwnames[] = {
36286 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36287 };
36288
36289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36293 }
36294 arg1 = reinterpret_cast< wxWindow * >(argp1);
36295 ecode2 = SWIG_AsVal_int(obj1, &val2);
36296 if (!SWIG_IsOK(ecode2)) {
36297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36298 }
36299 arg2 = static_cast< int >(val2);
36300 ecode3 = SWIG_AsVal_int(obj2, &val3);
36301 if (!SWIG_IsOK(ecode3)) {
36302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36303 }
36304 arg3 = static_cast< int >(val3);
36305 if (obj3) {
36306 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36307 if (!SWIG_IsOK(ecode4)) {
36308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36309 }
36310 arg4 = static_cast< bool >(val4);
36311 }
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 (arg1)->SetScrollPos(arg2,arg3,arg4);
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_Py_Void();
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36326 PyObject *resultobj = 0;
36327 wxWindow *arg1 = (wxWindow *) 0 ;
36328 int arg2 ;
36329 int result;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 int val2 ;
36333 int ecode2 = 0 ;
36334 PyObject * obj0 = 0 ;
36335 PyObject * obj1 = 0 ;
36336 char * kwnames[] = {
36337 (char *) "self",(char *) "orientation", NULL
36338 };
36339
36340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36342 if (!SWIG_IsOK(res1)) {
36343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36344 }
36345 arg1 = reinterpret_cast< wxWindow * >(argp1);
36346 ecode2 = SWIG_AsVal_int(obj1, &val2);
36347 if (!SWIG_IsOK(ecode2)) {
36348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36349 }
36350 arg2 = static_cast< int >(val2);
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 resultobj = SWIG_From_int(static_cast< int >(result));
36358 return resultobj;
36359 fail:
36360 return NULL;
36361 }
36362
36363
36364 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36365 PyObject *resultobj = 0;
36366 wxWindow *arg1 = (wxWindow *) 0 ;
36367 int arg2 ;
36368 int result;
36369 void *argp1 = 0 ;
36370 int res1 = 0 ;
36371 int val2 ;
36372 int ecode2 = 0 ;
36373 PyObject * obj0 = 0 ;
36374 PyObject * obj1 = 0 ;
36375 char * kwnames[] = {
36376 (char *) "self",(char *) "orientation", NULL
36377 };
36378
36379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36381 if (!SWIG_IsOK(res1)) {
36382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36383 }
36384 arg1 = reinterpret_cast< wxWindow * >(argp1);
36385 ecode2 = SWIG_AsVal_int(obj1, &val2);
36386 if (!SWIG_IsOK(ecode2)) {
36387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36388 }
36389 arg2 = static_cast< int >(val2);
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 resultobj = SWIG_From_int(static_cast< int >(result));
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 int arg2 ;
36407 int result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 int val2 ;
36411 int ecode2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "orientation", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 ecode2 = SWIG_AsVal_int(obj1, &val2);
36425 if (!SWIG_IsOK(ecode2)) {
36426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36427 }
36428 arg2 = static_cast< int >(val2);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 resultobj = SWIG_From_int(static_cast< int >(result));
36436 return resultobj;
36437 fail:
36438 return NULL;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36443 PyObject *resultobj = 0;
36444 wxWindow *arg1 = (wxWindow *) 0 ;
36445 int arg2 ;
36446 int arg3 ;
36447 wxRect *arg4 = (wxRect *) NULL ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 int val2 ;
36451 int ecode2 = 0 ;
36452 int val3 ;
36453 int ecode3 = 0 ;
36454 void *argp4 = 0 ;
36455 int res4 = 0 ;
36456 PyObject * obj0 = 0 ;
36457 PyObject * obj1 = 0 ;
36458 PyObject * obj2 = 0 ;
36459 PyObject * obj3 = 0 ;
36460 char * kwnames[] = {
36461 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36462 };
36463
36464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36466 if (!SWIG_IsOK(res1)) {
36467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36468 }
36469 arg1 = reinterpret_cast< wxWindow * >(argp1);
36470 ecode2 = SWIG_AsVal_int(obj1, &val2);
36471 if (!SWIG_IsOK(ecode2)) {
36472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36473 }
36474 arg2 = static_cast< int >(val2);
36475 ecode3 = SWIG_AsVal_int(obj2, &val3);
36476 if (!SWIG_IsOK(ecode3)) {
36477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36478 }
36479 arg3 = static_cast< int >(val3);
36480 if (obj3) {
36481 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36482 if (!SWIG_IsOK(res4)) {
36483 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36484 }
36485 arg4 = reinterpret_cast< wxRect * >(argp4);
36486 }
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 resultobj = SWIG_Py_Void();
36494 return resultobj;
36495 fail:
36496 return NULL;
36497 }
36498
36499
36500 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36501 PyObject *resultobj = 0;
36502 wxWindow *arg1 = (wxWindow *) 0 ;
36503 int arg2 ;
36504 bool result;
36505 void *argp1 = 0 ;
36506 int res1 = 0 ;
36507 int val2 ;
36508 int ecode2 = 0 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char * kwnames[] = {
36512 (char *) "self",(char *) "lines", NULL
36513 };
36514
36515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36517 if (!SWIG_IsOK(res1)) {
36518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36519 }
36520 arg1 = reinterpret_cast< wxWindow * >(argp1);
36521 ecode2 = SWIG_AsVal_int(obj1, &val2);
36522 if (!SWIG_IsOK(ecode2)) {
36523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36524 }
36525 arg2 = static_cast< int >(val2);
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 result = (bool)(arg1)->ScrollLines(arg2);
36529 wxPyEndAllowThreads(__tstate);
36530 if (PyErr_Occurred()) SWIG_fail;
36531 }
36532 {
36533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36534 }
36535 return resultobj;
36536 fail:
36537 return NULL;
36538 }
36539
36540
36541 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj = 0;
36543 wxWindow *arg1 = (wxWindow *) 0 ;
36544 int arg2 ;
36545 bool result;
36546 void *argp1 = 0 ;
36547 int res1 = 0 ;
36548 int val2 ;
36549 int ecode2 = 0 ;
36550 PyObject * obj0 = 0 ;
36551 PyObject * obj1 = 0 ;
36552 char * kwnames[] = {
36553 (char *) "self",(char *) "pages", NULL
36554 };
36555
36556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36560 }
36561 arg1 = reinterpret_cast< wxWindow * >(argp1);
36562 ecode2 = SWIG_AsVal_int(obj1, &val2);
36563 if (!SWIG_IsOK(ecode2)) {
36564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36565 }
36566 arg2 = static_cast< int >(val2);
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 result = (bool)(arg1)->ScrollPages(arg2);
36570 wxPyEndAllowThreads(__tstate);
36571 if (PyErr_Occurred()) SWIG_fail;
36572 }
36573 {
36574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 bool result;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (bool)(arg1)->LineUp();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 {
36604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36605 }
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 bool result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 PyObject *swig_obj[1] ;
36619
36620 if (!args) SWIG_fail;
36621 swig_obj[0] = args;
36622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36623 if (!SWIG_IsOK(res1)) {
36624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36625 }
36626 arg1 = reinterpret_cast< wxWindow * >(argp1);
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 result = (bool)(arg1)->LineDown();
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36635 }
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36643 PyObject *resultobj = 0;
36644 wxWindow *arg1 = (wxWindow *) 0 ;
36645 bool result;
36646 void *argp1 = 0 ;
36647 int res1 = 0 ;
36648 PyObject *swig_obj[1] ;
36649
36650 if (!args) SWIG_fail;
36651 swig_obj[0] = args;
36652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36653 if (!SWIG_IsOK(res1)) {
36654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36655 }
36656 arg1 = reinterpret_cast< wxWindow * >(argp1);
36657 {
36658 PyThreadState* __tstate = wxPyBeginAllowThreads();
36659 result = (bool)(arg1)->PageUp();
36660 wxPyEndAllowThreads(__tstate);
36661 if (PyErr_Occurred()) SWIG_fail;
36662 }
36663 {
36664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36665 }
36666 return resultobj;
36667 fail:
36668 return NULL;
36669 }
36670
36671
36672 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36673 PyObject *resultobj = 0;
36674 wxWindow *arg1 = (wxWindow *) 0 ;
36675 bool result;
36676 void *argp1 = 0 ;
36677 int res1 = 0 ;
36678 PyObject *swig_obj[1] ;
36679
36680 if (!args) SWIG_fail;
36681 swig_obj[0] = args;
36682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36683 if (!SWIG_IsOK(res1)) {
36684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36685 }
36686 arg1 = reinterpret_cast< wxWindow * >(argp1);
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = (bool)(arg1)->PageDown();
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 {
36694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36695 }
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj = 0;
36704 wxWindow *arg1 = (wxWindow *) 0 ;
36705 wxString *arg2 = 0 ;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 bool temp2 = false ;
36709 PyObject * obj0 = 0 ;
36710 PyObject * obj1 = 0 ;
36711 char * kwnames[] = {
36712 (char *) "self",(char *) "text", NULL
36713 };
36714
36715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36717 if (!SWIG_IsOK(res1)) {
36718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36719 }
36720 arg1 = reinterpret_cast< wxWindow * >(argp1);
36721 {
36722 arg2 = wxString_in_helper(obj1);
36723 if (arg2 == NULL) SWIG_fail;
36724 temp2 = true;
36725 }
36726 {
36727 PyThreadState* __tstate = wxPyBeginAllowThreads();
36728 (arg1)->SetHelpText((wxString const &)*arg2);
36729 wxPyEndAllowThreads(__tstate);
36730 if (PyErr_Occurred()) SWIG_fail;
36731 }
36732 resultobj = SWIG_Py_Void();
36733 {
36734 if (temp2)
36735 delete arg2;
36736 }
36737 return resultobj;
36738 fail:
36739 {
36740 if (temp2)
36741 delete arg2;
36742 }
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36748 PyObject *resultobj = 0;
36749 wxWindow *arg1 = (wxWindow *) 0 ;
36750 wxString *arg2 = 0 ;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 bool temp2 = false ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "text", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 {
36767 arg2 = wxString_in_helper(obj1);
36768 if (arg2 == NULL) SWIG_fail;
36769 temp2 = true;
36770 }
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 resultobj = SWIG_Py_Void();
36778 {
36779 if (temp2)
36780 delete arg2;
36781 }
36782 return resultobj;
36783 fail:
36784 {
36785 if (temp2)
36786 delete arg2;
36787 }
36788 return NULL;
36789 }
36790
36791
36792 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36793 PyObject *resultobj = 0;
36794 wxWindow *arg1 = (wxWindow *) 0 ;
36795 wxString result;
36796 void *argp1 = 0 ;
36797 int res1 = 0 ;
36798 PyObject *swig_obj[1] ;
36799
36800 if (!args) SWIG_fail;
36801 swig_obj[0] = args;
36802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36803 if (!SWIG_IsOK(res1)) {
36804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36805 }
36806 arg1 = reinterpret_cast< wxWindow * >(argp1);
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 result = ((wxWindow const *)arg1)->GetHelpText();
36810 wxPyEndAllowThreads(__tstate);
36811 if (PyErr_Occurred()) SWIG_fail;
36812 }
36813 {
36814 #if wxUSE_UNICODE
36815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36816 #else
36817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36818 #endif
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 wxString *arg2 = 0 ;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 bool temp2 = false ;
36833 PyObject * obj0 = 0 ;
36834 PyObject * obj1 = 0 ;
36835 char * kwnames[] = {
36836 (char *) "self",(char *) "tip", NULL
36837 };
36838
36839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36841 if (!SWIG_IsOK(res1)) {
36842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36843 }
36844 arg1 = reinterpret_cast< wxWindow * >(argp1);
36845 {
36846 arg2 = wxString_in_helper(obj1);
36847 if (arg2 == NULL) SWIG_fail;
36848 temp2 = true;
36849 }
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 (arg1)->SetToolTip((wxString const &)*arg2);
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 resultobj = SWIG_Py_Void();
36857 {
36858 if (temp2)
36859 delete arg2;
36860 }
36861 return resultobj;
36862 fail:
36863 {
36864 if (temp2)
36865 delete arg2;
36866 }
36867 return NULL;
36868 }
36869
36870
36871 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36872 PyObject *resultobj = 0;
36873 wxWindow *arg1 = (wxWindow *) 0 ;
36874 wxToolTip *arg2 = (wxToolTip *) 0 ;
36875 void *argp1 = 0 ;
36876 int res1 = 0 ;
36877 int res2 = 0 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char * kwnames[] = {
36881 (char *) "self",(char *) "tip", NULL
36882 };
36883
36884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36886 if (!SWIG_IsOK(res1)) {
36887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36888 }
36889 arg1 = reinterpret_cast< wxWindow * >(argp1);
36890 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36891 if (!SWIG_IsOK(res2)) {
36892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36893 }
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 (arg1)->SetToolTip(arg2);
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 resultobj = SWIG_Py_Void();
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36908 PyObject *resultobj = 0;
36909 wxWindow *arg1 = (wxWindow *) 0 ;
36910 wxToolTip *result = 0 ;
36911 void *argp1 = 0 ;
36912 int res1 = 0 ;
36913 PyObject *swig_obj[1] ;
36914
36915 if (!args) SWIG_fail;
36916 swig_obj[0] = args;
36917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 {
36929 resultobj = wxPyMake_wxObject(result, (bool)0);
36930 }
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36938 PyObject *resultobj = 0;
36939 wxWindow *arg1 = (wxWindow *) 0 ;
36940 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36941 void *argp1 = 0 ;
36942 int res1 = 0 ;
36943 int res2 = 0 ;
36944 PyObject * obj0 = 0 ;
36945 PyObject * obj1 = 0 ;
36946 char * kwnames[] = {
36947 (char *) "self",(char *) "dropTarget", NULL
36948 };
36949
36950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36954 }
36955 arg1 = reinterpret_cast< wxWindow * >(argp1);
36956 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36957 if (!SWIG_IsOK(res2)) {
36958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36959 }
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 (arg1)->SetDropTarget(arg2);
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 resultobj = SWIG_Py_Void();
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxPyDropTarget *result = 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 PyObject *swig_obj[1] ;
36980
36981 if (!args) SWIG_fail;
36982 swig_obj[0] = args;
36983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36986 }
36987 arg1 = reinterpret_cast< wxWindow * >(argp1);
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 bool arg2 ;
37005 void *argp1 = 0 ;
37006 int res1 = 0 ;
37007 bool val2 ;
37008 int ecode2 = 0 ;
37009 PyObject * obj0 = 0 ;
37010 PyObject * obj1 = 0 ;
37011 char * kwnames[] = {
37012 (char *) "self",(char *) "accept", NULL
37013 };
37014
37015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37017 if (!SWIG_IsOK(res1)) {
37018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37019 }
37020 arg1 = reinterpret_cast< wxWindow * >(argp1);
37021 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37022 if (!SWIG_IsOK(ecode2)) {
37023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37024 }
37025 arg2 = static_cast< bool >(val2);
37026 {
37027 PyThreadState* __tstate = wxPyBeginAllowThreads();
37028 (arg1)->DragAcceptFiles(arg2);
37029 wxPyEndAllowThreads(__tstate);
37030 if (PyErr_Occurred()) SWIG_fail;
37031 }
37032 resultobj = SWIG_Py_Void();
37033 return resultobj;
37034 fail:
37035 return NULL;
37036 }
37037
37038
37039 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37040 PyObject *resultobj = 0;
37041 wxWindow *arg1 = (wxWindow *) 0 ;
37042 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37043 void *argp1 = 0 ;
37044 int res1 = 0 ;
37045 int res2 = 0 ;
37046 PyObject * obj0 = 0 ;
37047 PyObject * obj1 = 0 ;
37048 char * kwnames[] = {
37049 (char *) "self",(char *) "constraints", NULL
37050 };
37051
37052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37059 if (!SWIG_IsOK(res2)) {
37060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37061 }
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 (arg1)->SetConstraints(arg2);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 resultobj = SWIG_Py_Void();
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37076 PyObject *resultobj = 0;
37077 wxWindow *arg1 = (wxWindow *) 0 ;
37078 wxLayoutConstraints *result = 0 ;
37079 void *argp1 = 0 ;
37080 int res1 = 0 ;
37081 PyObject *swig_obj[1] ;
37082
37083 if (!args) SWIG_fail;
37084 swig_obj[0] = args;
37085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37097 return resultobj;
37098 fail:
37099 return NULL;
37100 }
37101
37102
37103 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37104 PyObject *resultobj = 0;
37105 wxWindow *arg1 = (wxWindow *) 0 ;
37106 bool arg2 ;
37107 void *argp1 = 0 ;
37108 int res1 = 0 ;
37109 bool val2 ;
37110 int ecode2 = 0 ;
37111 PyObject * obj0 = 0 ;
37112 PyObject * obj1 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "self",(char *) "autoLayout", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37121 }
37122 arg1 = reinterpret_cast< wxWindow * >(argp1);
37123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37124 if (!SWIG_IsOK(ecode2)) {
37125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37126 }
37127 arg2 = static_cast< bool >(val2);
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 (arg1)->SetAutoLayout(arg2);
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 resultobj = SWIG_Py_Void();
37135 return resultobj;
37136 fail:
37137 return NULL;
37138 }
37139
37140
37141 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37142 PyObject *resultobj = 0;
37143 wxWindow *arg1 = (wxWindow *) 0 ;
37144 bool result;
37145 void *argp1 = 0 ;
37146 int res1 = 0 ;
37147 PyObject *swig_obj[1] ;
37148
37149 if (!args) SWIG_fail;
37150 swig_obj[0] = args;
37151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37154 }
37155 arg1 = reinterpret_cast< wxWindow * >(argp1);
37156 {
37157 PyThreadState* __tstate = wxPyBeginAllowThreads();
37158 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 bool result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 PyObject *swig_obj[1] ;
37178
37179 if (!args) SWIG_fail;
37180 swig_obj[0] = args;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (bool)(arg1)->Layout();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 {
37193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxSizer *arg2 = (wxSizer *) 0 ;
37205 bool arg3 = (bool) true ;
37206 void *argp1 = 0 ;
37207 int res1 = 0 ;
37208 int res2 = 0 ;
37209 bool val3 ;
37210 int ecode3 = 0 ;
37211 PyObject * obj0 = 0 ;
37212 PyObject * obj1 = 0 ;
37213 PyObject * obj2 = 0 ;
37214 char * kwnames[] = {
37215 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37216 };
37217
37218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37220 if (!SWIG_IsOK(res1)) {
37221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37222 }
37223 arg1 = reinterpret_cast< wxWindow * >(argp1);
37224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37225 if (!SWIG_IsOK(res2)) {
37226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37227 }
37228 if (obj2) {
37229 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37230 if (!SWIG_IsOK(ecode3)) {
37231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37232 }
37233 arg3 = static_cast< bool >(val3);
37234 }
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 (arg1)->SetSizer(arg2,arg3);
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 resultobj = SWIG_Py_Void();
37242 return resultobj;
37243 fail:
37244 return NULL;
37245 }
37246
37247
37248 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37249 PyObject *resultobj = 0;
37250 wxWindow *arg1 = (wxWindow *) 0 ;
37251 wxSizer *arg2 = (wxSizer *) 0 ;
37252 bool arg3 = (bool) true ;
37253 void *argp1 = 0 ;
37254 int res1 = 0 ;
37255 int res2 = 0 ;
37256 bool val3 ;
37257 int ecode3 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 PyObject * obj2 = 0 ;
37261 char * kwnames[] = {
37262 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37263 };
37264
37265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37267 if (!SWIG_IsOK(res1)) {
37268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37269 }
37270 arg1 = reinterpret_cast< wxWindow * >(argp1);
37271 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37272 if (!SWIG_IsOK(res2)) {
37273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37274 }
37275 if (obj2) {
37276 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37277 if (!SWIG_IsOK(ecode3)) {
37278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37279 }
37280 arg3 = static_cast< bool >(val3);
37281 }
37282 {
37283 PyThreadState* __tstate = wxPyBeginAllowThreads();
37284 (arg1)->SetSizerAndFit(arg2,arg3);
37285 wxPyEndAllowThreads(__tstate);
37286 if (PyErr_Occurred()) SWIG_fail;
37287 }
37288 resultobj = SWIG_Py_Void();
37289 return resultobj;
37290 fail:
37291 return NULL;
37292 }
37293
37294
37295 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37296 PyObject *resultobj = 0;
37297 wxWindow *arg1 = (wxWindow *) 0 ;
37298 wxSizer *result = 0 ;
37299 void *argp1 = 0 ;
37300 int res1 = 0 ;
37301 PyObject *swig_obj[1] ;
37302
37303 if (!args) SWIG_fail;
37304 swig_obj[0] = args;
37305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37306 if (!SWIG_IsOK(res1)) {
37307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37308 }
37309 arg1 = reinterpret_cast< wxWindow * >(argp1);
37310 {
37311 PyThreadState* __tstate = wxPyBeginAllowThreads();
37312 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 {
37317 resultobj = wxPyMake_wxObject(result, (bool)0);
37318 }
37319 return resultobj;
37320 fail:
37321 return NULL;
37322 }
37323
37324
37325 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37326 PyObject *resultobj = 0;
37327 wxWindow *arg1 = (wxWindow *) 0 ;
37328 wxSizer *arg2 = (wxSizer *) 0 ;
37329 void *argp1 = 0 ;
37330 int res1 = 0 ;
37331 void *argp2 = 0 ;
37332 int res2 = 0 ;
37333 PyObject * obj0 = 0 ;
37334 PyObject * obj1 = 0 ;
37335 char * kwnames[] = {
37336 (char *) "self",(char *) "sizer", NULL
37337 };
37338
37339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37341 if (!SWIG_IsOK(res1)) {
37342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37343 }
37344 arg1 = reinterpret_cast< wxWindow * >(argp1);
37345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37346 if (!SWIG_IsOK(res2)) {
37347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37348 }
37349 arg2 = reinterpret_cast< wxSizer * >(argp2);
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 (arg1)->SetContainingSizer(arg2);
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 resultobj = SWIG_Py_Void();
37357 return resultobj;
37358 fail:
37359 return NULL;
37360 }
37361
37362
37363 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37364 PyObject *resultobj = 0;
37365 wxWindow *arg1 = (wxWindow *) 0 ;
37366 wxSizer *result = 0 ;
37367 void *argp1 = 0 ;
37368 int res1 = 0 ;
37369 PyObject *swig_obj[1] ;
37370
37371 if (!args) SWIG_fail;
37372 swig_obj[0] = args;
37373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37381 wxPyEndAllowThreads(__tstate);
37382 if (PyErr_Occurred()) SWIG_fail;
37383 }
37384 {
37385 resultobj = wxPyMake_wxObject(result, (bool)0);
37386 }
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37394 PyObject *resultobj = 0;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 void *argp1 = 0 ;
37397 int res1 = 0 ;
37398 PyObject *swig_obj[1] ;
37399
37400 if (!args) SWIG_fail;
37401 swig_obj[0] = args;
37402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37403 if (!SWIG_IsOK(res1)) {
37404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37405 }
37406 arg1 = reinterpret_cast< wxWindow * >(argp1);
37407 {
37408 PyThreadState* __tstate = wxPyBeginAllowThreads();
37409 (arg1)->InheritAttributes();
37410 wxPyEndAllowThreads(__tstate);
37411 if (PyErr_Occurred()) SWIG_fail;
37412 }
37413 resultobj = SWIG_Py_Void();
37414 return resultobj;
37415 fail:
37416 return NULL;
37417 }
37418
37419
37420 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37421 PyObject *resultobj = 0;
37422 wxWindow *arg1 = (wxWindow *) 0 ;
37423 bool result;
37424 void *argp1 = 0 ;
37425 int res1 = 0 ;
37426 PyObject *swig_obj[1] ;
37427
37428 if (!args) SWIG_fail;
37429 swig_obj[0] = args;
37430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37431 if (!SWIG_IsOK(res1)) {
37432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37433 }
37434 arg1 = reinterpret_cast< wxWindow * >(argp1);
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 {
37442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37443 }
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37451 PyObject *obj;
37452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37453 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37454 return SWIG_Py_Void();
37455 }
37456
37457 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37458 return SWIG_Python_InitShadowInstance(args);
37459 }
37460
37461 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37462 PyObject *resultobj = 0;
37463 long arg1 ;
37464 wxWindow *arg2 = (wxWindow *) NULL ;
37465 wxWindow *result = 0 ;
37466 long val1 ;
37467 int ecode1 = 0 ;
37468 void *argp2 = 0 ;
37469 int res2 = 0 ;
37470 PyObject * obj0 = 0 ;
37471 PyObject * obj1 = 0 ;
37472 char * kwnames[] = {
37473 (char *) "id",(char *) "parent", NULL
37474 };
37475
37476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37477 ecode1 = SWIG_AsVal_long(obj0, &val1);
37478 if (!SWIG_IsOK(ecode1)) {
37479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37480 }
37481 arg1 = static_cast< long >(val1);
37482 if (obj1) {
37483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37484 if (!SWIG_IsOK(res2)) {
37485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37486 }
37487 arg2 = reinterpret_cast< wxWindow * >(argp2);
37488 }
37489 {
37490 if (!wxPyCheckForApp()) SWIG_fail;
37491 PyThreadState* __tstate = wxPyBeginAllowThreads();
37492 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 {
37497 resultobj = wxPyMake_wxObject(result, 0);
37498 }
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37506 PyObject *resultobj = 0;
37507 wxString *arg1 = 0 ;
37508 wxWindow *arg2 = (wxWindow *) NULL ;
37509 wxWindow *result = 0 ;
37510 bool temp1 = false ;
37511 void *argp2 = 0 ;
37512 int res2 = 0 ;
37513 PyObject * obj0 = 0 ;
37514 PyObject * obj1 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "name",(char *) "parent", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37520 {
37521 arg1 = wxString_in_helper(obj0);
37522 if (arg1 == NULL) SWIG_fail;
37523 temp1 = true;
37524 }
37525 if (obj1) {
37526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37527 if (!SWIG_IsOK(res2)) {
37528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37529 }
37530 arg2 = reinterpret_cast< wxWindow * >(argp2);
37531 }
37532 {
37533 if (!wxPyCheckForApp()) SWIG_fail;
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37536 wxPyEndAllowThreads(__tstate);
37537 if (PyErr_Occurred()) SWIG_fail;
37538 }
37539 {
37540 resultobj = wxPyMake_wxObject(result, 0);
37541 }
37542 {
37543 if (temp1)
37544 delete arg1;
37545 }
37546 return resultobj;
37547 fail:
37548 {
37549 if (temp1)
37550 delete arg1;
37551 }
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37557 PyObject *resultobj = 0;
37558 wxString *arg1 = 0 ;
37559 wxWindow *arg2 = (wxWindow *) NULL ;
37560 wxWindow *result = 0 ;
37561 bool temp1 = false ;
37562 void *argp2 = 0 ;
37563 int res2 = 0 ;
37564 PyObject * obj0 = 0 ;
37565 PyObject * obj1 = 0 ;
37566 char * kwnames[] = {
37567 (char *) "label",(char *) "parent", NULL
37568 };
37569
37570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37571 {
37572 arg1 = wxString_in_helper(obj0);
37573 if (arg1 == NULL) SWIG_fail;
37574 temp1 = true;
37575 }
37576 if (obj1) {
37577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37578 if (!SWIG_IsOK(res2)) {
37579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37580 }
37581 arg2 = reinterpret_cast< wxWindow * >(argp2);
37582 }
37583 {
37584 if (!wxPyCheckForApp()) SWIG_fail;
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 resultobj = wxPyMake_wxObject(result, 0);
37592 }
37593 {
37594 if (temp1)
37595 delete arg1;
37596 }
37597 return resultobj;
37598 fail:
37599 {
37600 if (temp1)
37601 delete arg1;
37602 }
37603 return NULL;
37604 }
37605
37606
37607 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37608 PyObject *resultobj = 0;
37609 wxWindow *arg1 = (wxWindow *) 0 ;
37610 unsigned long arg2 ;
37611 wxWindow *result = 0 ;
37612 void *argp1 = 0 ;
37613 int res1 = 0 ;
37614 unsigned long val2 ;
37615 int ecode2 = 0 ;
37616 PyObject * obj0 = 0 ;
37617 PyObject * obj1 = 0 ;
37618 char * kwnames[] = {
37619 (char *) "parent",(char *) "_hWnd", NULL
37620 };
37621
37622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37624 if (!SWIG_IsOK(res1)) {
37625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37626 }
37627 arg1 = reinterpret_cast< wxWindow * >(argp1);
37628 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37629 if (!SWIG_IsOK(ecode2)) {
37630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37631 }
37632 arg2 = static_cast< unsigned long >(val2);
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37636 wxPyEndAllowThreads(__tstate);
37637 if (PyErr_Occurred()) SWIG_fail;
37638 }
37639 {
37640 resultobj = wxPyMake_wxObject(result, 0);
37641 }
37642 return resultobj;
37643 fail:
37644 return NULL;
37645 }
37646
37647
37648 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37649 PyObject *resultobj = 0;
37650 PyObject *result = 0 ;
37651
37652 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 result = (PyObject *)GetTopLevelWindows();
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 resultobj = result;
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37667 PyObject *resultobj = 0;
37668 wxValidator *result = 0 ;
37669
37670 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37671 {
37672 PyThreadState* __tstate = wxPyBeginAllowThreads();
37673 result = (wxValidator *)new wxValidator();
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37678 return resultobj;
37679 fail:
37680 return NULL;
37681 }
37682
37683
37684 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37685 PyObject *resultobj = 0;
37686 wxValidator *arg1 = (wxValidator *) 0 ;
37687 wxValidator *result = 0 ;
37688 void *argp1 = 0 ;
37689 int res1 = 0 ;
37690 PyObject *swig_obj[1] ;
37691
37692 if (!args) SWIG_fail;
37693 swig_obj[0] = args;
37694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37695 if (!SWIG_IsOK(res1)) {
37696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37697 }
37698 arg1 = reinterpret_cast< wxValidator * >(argp1);
37699 {
37700 PyThreadState* __tstate = wxPyBeginAllowThreads();
37701 result = (wxValidator *)(arg1)->Clone();
37702 wxPyEndAllowThreads(__tstate);
37703 if (PyErr_Occurred()) SWIG_fail;
37704 }
37705 {
37706 resultobj = wxPyMake_wxObject(result, 0);
37707 }
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37715 PyObject *resultobj = 0;
37716 wxValidator *arg1 = (wxValidator *) 0 ;
37717 wxWindow *arg2 = (wxWindow *) 0 ;
37718 bool result;
37719 void *argp1 = 0 ;
37720 int res1 = 0 ;
37721 void *argp2 = 0 ;
37722 int res2 = 0 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "self",(char *) "parent", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37733 }
37734 arg1 = reinterpret_cast< wxValidator * >(argp1);
37735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37736 if (!SWIG_IsOK(res2)) {
37737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37738 }
37739 arg2 = reinterpret_cast< wxWindow * >(argp2);
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 result = (bool)(arg1)->Validate(arg2);
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 {
37747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37748 }
37749 return resultobj;
37750 fail:
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37756 PyObject *resultobj = 0;
37757 wxValidator *arg1 = (wxValidator *) 0 ;
37758 bool result;
37759 void *argp1 = 0 ;
37760 int res1 = 0 ;
37761 PyObject *swig_obj[1] ;
37762
37763 if (!args) SWIG_fail;
37764 swig_obj[0] = args;
37765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37766 if (!SWIG_IsOK(res1)) {
37767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37768 }
37769 arg1 = reinterpret_cast< wxValidator * >(argp1);
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 result = (bool)(arg1)->TransferToWindow();
37773 wxPyEndAllowThreads(__tstate);
37774 if (PyErr_Occurred()) SWIG_fail;
37775 }
37776 {
37777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37778 }
37779 return resultobj;
37780 fail:
37781 return NULL;
37782 }
37783
37784
37785 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37786 PyObject *resultobj = 0;
37787 wxValidator *arg1 = (wxValidator *) 0 ;
37788 bool result;
37789 void *argp1 = 0 ;
37790 int res1 = 0 ;
37791 PyObject *swig_obj[1] ;
37792
37793 if (!args) SWIG_fail;
37794 swig_obj[0] = args;
37795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37796 if (!SWIG_IsOK(res1)) {
37797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37798 }
37799 arg1 = reinterpret_cast< wxValidator * >(argp1);
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (bool)(arg1)->TransferFromWindow();
37803 wxPyEndAllowThreads(__tstate);
37804 if (PyErr_Occurred()) SWIG_fail;
37805 }
37806 {
37807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37808 }
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37816 PyObject *resultobj = 0;
37817 wxValidator *arg1 = (wxValidator *) 0 ;
37818 wxWindow *result = 0 ;
37819 void *argp1 = 0 ;
37820 int res1 = 0 ;
37821 PyObject *swig_obj[1] ;
37822
37823 if (!args) SWIG_fail;
37824 swig_obj[0] = args;
37825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37826 if (!SWIG_IsOK(res1)) {
37827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37828 }
37829 arg1 = reinterpret_cast< wxValidator * >(argp1);
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 result = (wxWindow *)(arg1)->GetWindow();
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 {
37837 resultobj = wxPyMake_wxObject(result, 0);
37838 }
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37846 PyObject *resultobj = 0;
37847 wxValidator *arg1 = (wxValidator *) 0 ;
37848 wxWindow *arg2 = (wxWindow *) 0 ;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 void *argp2 = 0 ;
37852 int res2 = 0 ;
37853 PyObject * obj0 = 0 ;
37854 PyObject * obj1 = 0 ;
37855 char * kwnames[] = {
37856 (char *) "self",(char *) "window", NULL
37857 };
37858
37859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37861 if (!SWIG_IsOK(res1)) {
37862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37863 }
37864 arg1 = reinterpret_cast< wxValidator * >(argp1);
37865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37866 if (!SWIG_IsOK(res2)) {
37867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37868 }
37869 arg2 = reinterpret_cast< wxWindow * >(argp2);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 (arg1)->SetWindow(arg2);
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_Py_Void();
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 bool result;
37886
37887 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37888 {
37889 PyThreadState* __tstate = wxPyBeginAllowThreads();
37890 result = (bool)wxValidator::IsSilent();
37891 wxPyEndAllowThreads(__tstate);
37892 if (PyErr_Occurred()) SWIG_fail;
37893 }
37894 {
37895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37896 }
37897 return resultobj;
37898 fail:
37899 return NULL;
37900 }
37901
37902
37903 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37904 PyObject *resultobj = 0;
37905 int arg1 = (int) true ;
37906 int val1 ;
37907 int ecode1 = 0 ;
37908 PyObject * obj0 = 0 ;
37909 char * kwnames[] = {
37910 (char *) "doIt", NULL
37911 };
37912
37913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37914 if (obj0) {
37915 ecode1 = SWIG_AsVal_int(obj0, &val1);
37916 if (!SWIG_IsOK(ecode1)) {
37917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37918 }
37919 arg1 = static_cast< int >(val1);
37920 }
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 wxValidator::SetBellOnError(arg1);
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 resultobj = SWIG_Py_Void();
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37935 PyObject *obj;
37936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37937 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37938 return SWIG_Py_Void();
37939 }
37940
37941 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37942 return SWIG_Python_InitShadowInstance(args);
37943 }
37944
37945 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37946 PyObject *resultobj = 0;
37947 wxPyValidator *result = 0 ;
37948
37949 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 result = (wxPyValidator *)new wxPyValidator();
37953 wxPyEndAllowThreads(__tstate);
37954 if (PyErr_Occurred()) SWIG_fail;
37955 }
37956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37957 return resultobj;
37958 fail:
37959 return NULL;
37960 }
37961
37962
37963 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj = 0;
37965 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37966 PyObject *arg2 = (PyObject *) 0 ;
37967 PyObject *arg3 = (PyObject *) 0 ;
37968 int arg4 = (int) true ;
37969 void *argp1 = 0 ;
37970 int res1 = 0 ;
37971 int val4 ;
37972 int ecode4 = 0 ;
37973 PyObject * obj0 = 0 ;
37974 PyObject * obj1 = 0 ;
37975 PyObject * obj2 = 0 ;
37976 PyObject * obj3 = 0 ;
37977 char * kwnames[] = {
37978 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37979 };
37980
37981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37983 if (!SWIG_IsOK(res1)) {
37984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37985 }
37986 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37987 arg2 = obj1;
37988 arg3 = obj2;
37989 if (obj3) {
37990 ecode4 = SWIG_AsVal_int(obj3, &val4);
37991 if (!SWIG_IsOK(ecode4)) {
37992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37993 }
37994 arg4 = static_cast< int >(val4);
37995 }
37996 {
37997 PyThreadState* __tstate = wxPyBeginAllowThreads();
37998 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37999 wxPyEndAllowThreads(__tstate);
38000 if (PyErr_Occurred()) SWIG_fail;
38001 }
38002 resultobj = SWIG_Py_Void();
38003 return resultobj;
38004 fail:
38005 return NULL;
38006 }
38007
38008
38009 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38010 PyObject *obj;
38011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38012 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38013 return SWIG_Py_Void();
38014 }
38015
38016 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38017 return SWIG_Python_InitShadowInstance(args);
38018 }
38019
38020 SWIGINTERN int DefaultValidator_set(PyObject *) {
38021 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38022 return 1;
38023 }
38024
38025
38026 SWIGINTERN PyObject *DefaultValidator_get(void) {
38027 PyObject *pyobj = 0;
38028
38029 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38030 return pyobj;
38031 }
38032
38033
38034 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38035 PyObject *resultobj = 0;
38036 wxString const &arg1_defvalue = wxPyEmptyString ;
38037 wxString *arg1 = (wxString *) &arg1_defvalue ;
38038 long arg2 = (long) 0 ;
38039 wxMenu *result = 0 ;
38040 bool temp1 = false ;
38041 long val2 ;
38042 int ecode2 = 0 ;
38043 PyObject * obj0 = 0 ;
38044 PyObject * obj1 = 0 ;
38045 char * kwnames[] = {
38046 (char *) "title",(char *) "style", NULL
38047 };
38048
38049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38050 if (obj0) {
38051 {
38052 arg1 = wxString_in_helper(obj0);
38053 if (arg1 == NULL) SWIG_fail;
38054 temp1 = true;
38055 }
38056 }
38057 if (obj1) {
38058 ecode2 = SWIG_AsVal_long(obj1, &val2);
38059 if (!SWIG_IsOK(ecode2)) {
38060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38061 }
38062 arg2 = static_cast< long >(val2);
38063 }
38064 {
38065 if (!wxPyCheckForApp()) SWIG_fail;
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38072 {
38073 if (temp1)
38074 delete arg1;
38075 }
38076 return resultobj;
38077 fail:
38078 {
38079 if (temp1)
38080 delete arg1;
38081 }
38082 return NULL;
38083 }
38084
38085
38086 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38087 PyObject *resultobj = 0;
38088 wxMenu *arg1 = (wxMenu *) 0 ;
38089 int arg2 ;
38090 wxString *arg3 = 0 ;
38091 wxString const &arg4_defvalue = wxPyEmptyString ;
38092 wxString *arg4 = (wxString *) &arg4_defvalue ;
38093 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38094 wxMenuItem *result = 0 ;
38095 void *argp1 = 0 ;
38096 int res1 = 0 ;
38097 int val2 ;
38098 int ecode2 = 0 ;
38099 bool temp3 = false ;
38100 bool temp4 = false ;
38101 int val5 ;
38102 int ecode5 = 0 ;
38103 PyObject * obj0 = 0 ;
38104 PyObject * obj1 = 0 ;
38105 PyObject * obj2 = 0 ;
38106 PyObject * obj3 = 0 ;
38107 PyObject * obj4 = 0 ;
38108 char * kwnames[] = {
38109 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38110 };
38111
38112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38114 if (!SWIG_IsOK(res1)) {
38115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38116 }
38117 arg1 = reinterpret_cast< wxMenu * >(argp1);
38118 ecode2 = SWIG_AsVal_int(obj1, &val2);
38119 if (!SWIG_IsOK(ecode2)) {
38120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38121 }
38122 arg2 = static_cast< int >(val2);
38123 {
38124 arg3 = wxString_in_helper(obj2);
38125 if (arg3 == NULL) SWIG_fail;
38126 temp3 = true;
38127 }
38128 if (obj3) {
38129 {
38130 arg4 = wxString_in_helper(obj3);
38131 if (arg4 == NULL) SWIG_fail;
38132 temp4 = true;
38133 }
38134 }
38135 if (obj4) {
38136 ecode5 = SWIG_AsVal_int(obj4, &val5);
38137 if (!SWIG_IsOK(ecode5)) {
38138 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38139 }
38140 arg5 = static_cast< wxItemKind >(val5);
38141 }
38142 {
38143 PyThreadState* __tstate = wxPyBeginAllowThreads();
38144 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38145 wxPyEndAllowThreads(__tstate);
38146 if (PyErr_Occurred()) SWIG_fail;
38147 }
38148 {
38149 resultobj = wxPyMake_wxObject(result, (bool)0);
38150 }
38151 {
38152 if (temp3)
38153 delete arg3;
38154 }
38155 {
38156 if (temp4)
38157 delete arg4;
38158 }
38159 return resultobj;
38160 fail:
38161 {
38162 if (temp3)
38163 delete arg3;
38164 }
38165 {
38166 if (temp4)
38167 delete arg4;
38168 }
38169 return NULL;
38170 }
38171
38172
38173 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38174 PyObject *resultobj = 0;
38175 wxMenu *arg1 = (wxMenu *) 0 ;
38176 wxMenuItem *result = 0 ;
38177 void *argp1 = 0 ;
38178 int res1 = 0 ;
38179 PyObject *swig_obj[1] ;
38180
38181 if (!args) SWIG_fail;
38182 swig_obj[0] = args;
38183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38186 }
38187 arg1 = reinterpret_cast< wxMenu * >(argp1);
38188 {
38189 PyThreadState* __tstate = wxPyBeginAllowThreads();
38190 result = (wxMenuItem *)(arg1)->AppendSeparator();
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 resultobj = wxPyMake_wxObject(result, (bool)0);
38196 }
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38204 PyObject *resultobj = 0;
38205 wxMenu *arg1 = (wxMenu *) 0 ;
38206 int arg2 ;
38207 wxString *arg3 = 0 ;
38208 wxString const &arg4_defvalue = wxPyEmptyString ;
38209 wxString *arg4 = (wxString *) &arg4_defvalue ;
38210 wxMenuItem *result = 0 ;
38211 void *argp1 = 0 ;
38212 int res1 = 0 ;
38213 int val2 ;
38214 int ecode2 = 0 ;
38215 bool temp3 = false ;
38216 bool temp4 = false ;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 PyObject * obj2 = 0 ;
38220 PyObject * obj3 = 0 ;
38221 char * kwnames[] = {
38222 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38223 };
38224
38225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38227 if (!SWIG_IsOK(res1)) {
38228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38229 }
38230 arg1 = reinterpret_cast< wxMenu * >(argp1);
38231 ecode2 = SWIG_AsVal_int(obj1, &val2);
38232 if (!SWIG_IsOK(ecode2)) {
38233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38234 }
38235 arg2 = static_cast< int >(val2);
38236 {
38237 arg3 = wxString_in_helper(obj2);
38238 if (arg3 == NULL) SWIG_fail;
38239 temp3 = true;
38240 }
38241 if (obj3) {
38242 {
38243 arg4 = wxString_in_helper(obj3);
38244 if (arg4 == NULL) SWIG_fail;
38245 temp4 = true;
38246 }
38247 }
38248 {
38249 PyThreadState* __tstate = wxPyBeginAllowThreads();
38250 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38251 wxPyEndAllowThreads(__tstate);
38252 if (PyErr_Occurred()) SWIG_fail;
38253 }
38254 {
38255 resultobj = wxPyMake_wxObject(result, (bool)0);
38256 }
38257 {
38258 if (temp3)
38259 delete arg3;
38260 }
38261 {
38262 if (temp4)
38263 delete arg4;
38264 }
38265 return resultobj;
38266 fail:
38267 {
38268 if (temp3)
38269 delete arg3;
38270 }
38271 {
38272 if (temp4)
38273 delete arg4;
38274 }
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38280 PyObject *resultobj = 0;
38281 wxMenu *arg1 = (wxMenu *) 0 ;
38282 int arg2 ;
38283 wxString *arg3 = 0 ;
38284 wxString const &arg4_defvalue = wxPyEmptyString ;
38285 wxString *arg4 = (wxString *) &arg4_defvalue ;
38286 wxMenuItem *result = 0 ;
38287 void *argp1 = 0 ;
38288 int res1 = 0 ;
38289 int val2 ;
38290 int ecode2 = 0 ;
38291 bool temp3 = false ;
38292 bool temp4 = false ;
38293 PyObject * obj0 = 0 ;
38294 PyObject * obj1 = 0 ;
38295 PyObject * obj2 = 0 ;
38296 PyObject * obj3 = 0 ;
38297 char * kwnames[] = {
38298 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38299 };
38300
38301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38303 if (!SWIG_IsOK(res1)) {
38304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38305 }
38306 arg1 = reinterpret_cast< wxMenu * >(argp1);
38307 ecode2 = SWIG_AsVal_int(obj1, &val2);
38308 if (!SWIG_IsOK(ecode2)) {
38309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38310 }
38311 arg2 = static_cast< int >(val2);
38312 {
38313 arg3 = wxString_in_helper(obj2);
38314 if (arg3 == NULL) SWIG_fail;
38315 temp3 = true;
38316 }
38317 if (obj3) {
38318 {
38319 arg4 = wxString_in_helper(obj3);
38320 if (arg4 == NULL) SWIG_fail;
38321 temp4 = true;
38322 }
38323 }
38324 {
38325 PyThreadState* __tstate = wxPyBeginAllowThreads();
38326 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38327 wxPyEndAllowThreads(__tstate);
38328 if (PyErr_Occurred()) SWIG_fail;
38329 }
38330 {
38331 resultobj = wxPyMake_wxObject(result, (bool)0);
38332 }
38333 {
38334 if (temp3)
38335 delete arg3;
38336 }
38337 {
38338 if (temp4)
38339 delete arg4;
38340 }
38341 return resultobj;
38342 fail:
38343 {
38344 if (temp3)
38345 delete arg3;
38346 }
38347 {
38348 if (temp4)
38349 delete arg4;
38350 }
38351 return NULL;
38352 }
38353
38354
38355 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38356 PyObject *resultobj = 0;
38357 wxMenu *arg1 = (wxMenu *) 0 ;
38358 int arg2 ;
38359 wxString *arg3 = 0 ;
38360 wxMenu *arg4 = (wxMenu *) 0 ;
38361 wxString const &arg5_defvalue = wxPyEmptyString ;
38362 wxString *arg5 = (wxString *) &arg5_defvalue ;
38363 wxMenuItem *result = 0 ;
38364 void *argp1 = 0 ;
38365 int res1 = 0 ;
38366 int val2 ;
38367 int ecode2 = 0 ;
38368 bool temp3 = false ;
38369 void *argp4 = 0 ;
38370 int res4 = 0 ;
38371 bool temp5 = false ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 PyObject * obj3 = 0 ;
38376 PyObject * obj4 = 0 ;
38377 char * kwnames[] = {
38378 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38379 };
38380
38381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 ecode2 = SWIG_AsVal_int(obj1, &val2);
38388 if (!SWIG_IsOK(ecode2)) {
38389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38390 }
38391 arg2 = static_cast< int >(val2);
38392 {
38393 arg3 = wxString_in_helper(obj2);
38394 if (arg3 == NULL) SWIG_fail;
38395 temp3 = true;
38396 }
38397 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38398 if (!SWIG_IsOK(res4)) {
38399 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38400 }
38401 arg4 = reinterpret_cast< wxMenu * >(argp4);
38402 if (obj4) {
38403 {
38404 arg5 = wxString_in_helper(obj4);
38405 if (arg5 == NULL) SWIG_fail;
38406 temp5 = true;
38407 }
38408 }
38409 {
38410 PyThreadState* __tstate = wxPyBeginAllowThreads();
38411 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38412 wxPyEndAllowThreads(__tstate);
38413 if (PyErr_Occurred()) SWIG_fail;
38414 }
38415 {
38416 resultobj = wxPyMake_wxObject(result, (bool)0);
38417 }
38418 {
38419 if (temp3)
38420 delete arg3;
38421 }
38422 {
38423 if (temp5)
38424 delete arg5;
38425 }
38426 return resultobj;
38427 fail:
38428 {
38429 if (temp3)
38430 delete arg3;
38431 }
38432 {
38433 if (temp5)
38434 delete arg5;
38435 }
38436 return NULL;
38437 }
38438
38439
38440 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38441 PyObject *resultobj = 0;
38442 wxMenu *arg1 = (wxMenu *) 0 ;
38443 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38444 wxMenuItem *result = 0 ;
38445 void *argp1 = 0 ;
38446 int res1 = 0 ;
38447 int res2 = 0 ;
38448 PyObject * obj0 = 0 ;
38449 PyObject * obj1 = 0 ;
38450 char * kwnames[] = {
38451 (char *) "self",(char *) "item", NULL
38452 };
38453
38454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38456 if (!SWIG_IsOK(res1)) {
38457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38458 }
38459 arg1 = reinterpret_cast< wxMenu * >(argp1);
38460 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38461 if (!SWIG_IsOK(res2)) {
38462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38463 }
38464 {
38465 PyThreadState* __tstate = wxPyBeginAllowThreads();
38466 result = (wxMenuItem *)(arg1)->Append(arg2);
38467 wxPyEndAllowThreads(__tstate);
38468 if (PyErr_Occurred()) SWIG_fail;
38469 }
38470 {
38471 resultobj = wxPyMake_wxObject(result, (bool)0);
38472 }
38473 return resultobj;
38474 fail:
38475 return NULL;
38476 }
38477
38478
38479 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj = 0;
38481 wxMenu *arg1 = (wxMenu *) 0 ;
38482 size_t arg2 ;
38483 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38484 wxMenuItem *result = 0 ;
38485 void *argp1 = 0 ;
38486 int res1 = 0 ;
38487 size_t val2 ;
38488 int ecode2 = 0 ;
38489 int res3 = 0 ;
38490 PyObject * obj0 = 0 ;
38491 PyObject * obj1 = 0 ;
38492 PyObject * obj2 = 0 ;
38493 char * kwnames[] = {
38494 (char *) "self",(char *) "pos",(char *) "item", NULL
38495 };
38496
38497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38499 if (!SWIG_IsOK(res1)) {
38500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38501 }
38502 arg1 = reinterpret_cast< wxMenu * >(argp1);
38503 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38504 if (!SWIG_IsOK(ecode2)) {
38505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38506 }
38507 arg2 = static_cast< size_t >(val2);
38508 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38509 if (!SWIG_IsOK(res3)) {
38510 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38511 }
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 {
38519 resultobj = wxPyMake_wxObject(result, (bool)0);
38520 }
38521 return resultobj;
38522 fail:
38523 return NULL;
38524 }
38525
38526
38527 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj = 0;
38529 wxMenu *arg1 = (wxMenu *) 0 ;
38530 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38531 wxMenuItem *result = 0 ;
38532 void *argp1 = 0 ;
38533 int res1 = 0 ;
38534 int res2 = 0 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 char * kwnames[] = {
38538 (char *) "self",(char *) "item", NULL
38539 };
38540
38541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38543 if (!SWIG_IsOK(res1)) {
38544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38545 }
38546 arg1 = reinterpret_cast< wxMenu * >(argp1);
38547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38548 if (!SWIG_IsOK(res2)) {
38549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38550 }
38551 {
38552 PyThreadState* __tstate = wxPyBeginAllowThreads();
38553 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38554 wxPyEndAllowThreads(__tstate);
38555 if (PyErr_Occurred()) SWIG_fail;
38556 }
38557 {
38558 resultobj = wxPyMake_wxObject(result, (bool)0);
38559 }
38560 return resultobj;
38561 fail:
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38567 PyObject *resultobj = 0;
38568 wxMenu *arg1 = (wxMenu *) 0 ;
38569 void *argp1 = 0 ;
38570 int res1 = 0 ;
38571 PyObject *swig_obj[1] ;
38572
38573 if (!args) SWIG_fail;
38574 swig_obj[0] = args;
38575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38576 if (!SWIG_IsOK(res1)) {
38577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38578 }
38579 arg1 = reinterpret_cast< wxMenu * >(argp1);
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 (arg1)->Break();
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 resultobj = SWIG_Py_Void();
38587 return resultobj;
38588 fail:
38589 return NULL;
38590 }
38591
38592
38593 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38594 PyObject *resultobj = 0;
38595 wxMenu *arg1 = (wxMenu *) 0 ;
38596 size_t arg2 ;
38597 int arg3 ;
38598 wxString *arg4 = 0 ;
38599 wxString const &arg5_defvalue = wxPyEmptyString ;
38600 wxString *arg5 = (wxString *) &arg5_defvalue ;
38601 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38602 wxMenuItem *result = 0 ;
38603 void *argp1 = 0 ;
38604 int res1 = 0 ;
38605 size_t val2 ;
38606 int ecode2 = 0 ;
38607 int val3 ;
38608 int ecode3 = 0 ;
38609 bool temp4 = false ;
38610 bool temp5 = false ;
38611 int val6 ;
38612 int ecode6 = 0 ;
38613 PyObject * obj0 = 0 ;
38614 PyObject * obj1 = 0 ;
38615 PyObject * obj2 = 0 ;
38616 PyObject * obj3 = 0 ;
38617 PyObject * obj4 = 0 ;
38618 PyObject * obj5 = 0 ;
38619 char * kwnames[] = {
38620 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38621 };
38622
38623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38625 if (!SWIG_IsOK(res1)) {
38626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38627 }
38628 arg1 = reinterpret_cast< wxMenu * >(argp1);
38629 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38630 if (!SWIG_IsOK(ecode2)) {
38631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38632 }
38633 arg2 = static_cast< size_t >(val2);
38634 ecode3 = SWIG_AsVal_int(obj2, &val3);
38635 if (!SWIG_IsOK(ecode3)) {
38636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38637 }
38638 arg3 = static_cast< int >(val3);
38639 {
38640 arg4 = wxString_in_helper(obj3);
38641 if (arg4 == NULL) SWIG_fail;
38642 temp4 = true;
38643 }
38644 if (obj4) {
38645 {
38646 arg5 = wxString_in_helper(obj4);
38647 if (arg5 == NULL) SWIG_fail;
38648 temp5 = true;
38649 }
38650 }
38651 if (obj5) {
38652 ecode6 = SWIG_AsVal_int(obj5, &val6);
38653 if (!SWIG_IsOK(ecode6)) {
38654 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38655 }
38656 arg6 = static_cast< wxItemKind >(val6);
38657 }
38658 {
38659 PyThreadState* __tstate = wxPyBeginAllowThreads();
38660 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38661 wxPyEndAllowThreads(__tstate);
38662 if (PyErr_Occurred()) SWIG_fail;
38663 }
38664 {
38665 resultobj = wxPyMake_wxObject(result, (bool)0);
38666 }
38667 {
38668 if (temp4)
38669 delete arg4;
38670 }
38671 {
38672 if (temp5)
38673 delete arg5;
38674 }
38675 return resultobj;
38676 fail:
38677 {
38678 if (temp4)
38679 delete arg4;
38680 }
38681 {
38682 if (temp5)
38683 delete arg5;
38684 }
38685 return NULL;
38686 }
38687
38688
38689 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38690 PyObject *resultobj = 0;
38691 wxMenu *arg1 = (wxMenu *) 0 ;
38692 size_t arg2 ;
38693 wxMenuItem *result = 0 ;
38694 void *argp1 = 0 ;
38695 int res1 = 0 ;
38696 size_t val2 ;
38697 int ecode2 = 0 ;
38698 PyObject * obj0 = 0 ;
38699 PyObject * obj1 = 0 ;
38700 char * kwnames[] = {
38701 (char *) "self",(char *) "pos", NULL
38702 };
38703
38704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38706 if (!SWIG_IsOK(res1)) {
38707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38708 }
38709 arg1 = reinterpret_cast< wxMenu * >(argp1);
38710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38711 if (!SWIG_IsOK(ecode2)) {
38712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38713 }
38714 arg2 = static_cast< size_t >(val2);
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 {
38722 resultobj = wxPyMake_wxObject(result, (bool)0);
38723 }
38724 return resultobj;
38725 fail:
38726 return NULL;
38727 }
38728
38729
38730 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38731 PyObject *resultobj = 0;
38732 wxMenu *arg1 = (wxMenu *) 0 ;
38733 size_t arg2 ;
38734 int arg3 ;
38735 wxString *arg4 = 0 ;
38736 wxString const &arg5_defvalue = wxPyEmptyString ;
38737 wxString *arg5 = (wxString *) &arg5_defvalue ;
38738 wxMenuItem *result = 0 ;
38739 void *argp1 = 0 ;
38740 int res1 = 0 ;
38741 size_t val2 ;
38742 int ecode2 = 0 ;
38743 int val3 ;
38744 int ecode3 = 0 ;
38745 bool temp4 = false ;
38746 bool temp5 = false ;
38747 PyObject * obj0 = 0 ;
38748 PyObject * obj1 = 0 ;
38749 PyObject * obj2 = 0 ;
38750 PyObject * obj3 = 0 ;
38751 PyObject * obj4 = 0 ;
38752 char * kwnames[] = {
38753 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38754 };
38755
38756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38760 }
38761 arg1 = reinterpret_cast< wxMenu * >(argp1);
38762 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38763 if (!SWIG_IsOK(ecode2)) {
38764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38765 }
38766 arg2 = static_cast< size_t >(val2);
38767 ecode3 = SWIG_AsVal_int(obj2, &val3);
38768 if (!SWIG_IsOK(ecode3)) {
38769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38770 }
38771 arg3 = static_cast< int >(val3);
38772 {
38773 arg4 = wxString_in_helper(obj3);
38774 if (arg4 == NULL) SWIG_fail;
38775 temp4 = true;
38776 }
38777 if (obj4) {
38778 {
38779 arg5 = wxString_in_helper(obj4);
38780 if (arg5 == NULL) SWIG_fail;
38781 temp5 = true;
38782 }
38783 }
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38787 wxPyEndAllowThreads(__tstate);
38788 if (PyErr_Occurred()) SWIG_fail;
38789 }
38790 {
38791 resultobj = wxPyMake_wxObject(result, (bool)0);
38792 }
38793 {
38794 if (temp4)
38795 delete arg4;
38796 }
38797 {
38798 if (temp5)
38799 delete arg5;
38800 }
38801 return resultobj;
38802 fail:
38803 {
38804 if (temp4)
38805 delete arg4;
38806 }
38807 {
38808 if (temp5)
38809 delete arg5;
38810 }
38811 return NULL;
38812 }
38813
38814
38815 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj = 0;
38817 wxMenu *arg1 = (wxMenu *) 0 ;
38818 size_t arg2 ;
38819 int arg3 ;
38820 wxString *arg4 = 0 ;
38821 wxString const &arg5_defvalue = wxPyEmptyString ;
38822 wxString *arg5 = (wxString *) &arg5_defvalue ;
38823 wxMenuItem *result = 0 ;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 size_t val2 ;
38827 int ecode2 = 0 ;
38828 int val3 ;
38829 int ecode3 = 0 ;
38830 bool temp4 = false ;
38831 bool temp5 = false ;
38832 PyObject * obj0 = 0 ;
38833 PyObject * obj1 = 0 ;
38834 PyObject * obj2 = 0 ;
38835 PyObject * obj3 = 0 ;
38836 PyObject * obj4 = 0 ;
38837 char * kwnames[] = {
38838 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38839 };
38840
38841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38843 if (!SWIG_IsOK(res1)) {
38844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38845 }
38846 arg1 = reinterpret_cast< wxMenu * >(argp1);
38847 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38848 if (!SWIG_IsOK(ecode2)) {
38849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38850 }
38851 arg2 = static_cast< size_t >(val2);
38852 ecode3 = SWIG_AsVal_int(obj2, &val3);
38853 if (!SWIG_IsOK(ecode3)) {
38854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38855 }
38856 arg3 = static_cast< int >(val3);
38857 {
38858 arg4 = wxString_in_helper(obj3);
38859 if (arg4 == NULL) SWIG_fail;
38860 temp4 = true;
38861 }
38862 if (obj4) {
38863 {
38864 arg5 = wxString_in_helper(obj4);
38865 if (arg5 == NULL) SWIG_fail;
38866 temp5 = true;
38867 }
38868 }
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38872 wxPyEndAllowThreads(__tstate);
38873 if (PyErr_Occurred()) SWIG_fail;
38874 }
38875 {
38876 resultobj = wxPyMake_wxObject(result, (bool)0);
38877 }
38878 {
38879 if (temp4)
38880 delete arg4;
38881 }
38882 {
38883 if (temp5)
38884 delete arg5;
38885 }
38886 return resultobj;
38887 fail:
38888 {
38889 if (temp4)
38890 delete arg4;
38891 }
38892 {
38893 if (temp5)
38894 delete arg5;
38895 }
38896 return NULL;
38897 }
38898
38899
38900 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38901 PyObject *resultobj = 0;
38902 wxMenu *arg1 = (wxMenu *) 0 ;
38903 size_t arg2 ;
38904 int arg3 ;
38905 wxString *arg4 = 0 ;
38906 wxMenu *arg5 = (wxMenu *) 0 ;
38907 wxString const &arg6_defvalue = wxPyEmptyString ;
38908 wxString *arg6 = (wxString *) &arg6_defvalue ;
38909 wxMenuItem *result = 0 ;
38910 void *argp1 = 0 ;
38911 int res1 = 0 ;
38912 size_t val2 ;
38913 int ecode2 = 0 ;
38914 int val3 ;
38915 int ecode3 = 0 ;
38916 bool temp4 = false ;
38917 void *argp5 = 0 ;
38918 int res5 = 0 ;
38919 bool temp6 = false ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 PyObject * obj2 = 0 ;
38923 PyObject * obj3 = 0 ;
38924 PyObject * obj4 = 0 ;
38925 PyObject * obj5 = 0 ;
38926 char * kwnames[] = {
38927 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38928 };
38929
38930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38932 if (!SWIG_IsOK(res1)) {
38933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38934 }
38935 arg1 = reinterpret_cast< wxMenu * >(argp1);
38936 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38937 if (!SWIG_IsOK(ecode2)) {
38938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38939 }
38940 arg2 = static_cast< size_t >(val2);
38941 ecode3 = SWIG_AsVal_int(obj2, &val3);
38942 if (!SWIG_IsOK(ecode3)) {
38943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38944 }
38945 arg3 = static_cast< int >(val3);
38946 {
38947 arg4 = wxString_in_helper(obj3);
38948 if (arg4 == NULL) SWIG_fail;
38949 temp4 = true;
38950 }
38951 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38952 if (!SWIG_IsOK(res5)) {
38953 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38954 }
38955 arg5 = reinterpret_cast< wxMenu * >(argp5);
38956 if (obj5) {
38957 {
38958 arg6 = wxString_in_helper(obj5);
38959 if (arg6 == NULL) SWIG_fail;
38960 temp6 = true;
38961 }
38962 }
38963 {
38964 PyThreadState* __tstate = wxPyBeginAllowThreads();
38965 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 resultobj = wxPyMake_wxObject(result, (bool)0);
38971 }
38972 {
38973 if (temp4)
38974 delete arg4;
38975 }
38976 {
38977 if (temp6)
38978 delete arg6;
38979 }
38980 return resultobj;
38981 fail:
38982 {
38983 if (temp4)
38984 delete arg4;
38985 }
38986 {
38987 if (temp6)
38988 delete arg6;
38989 }
38990 return NULL;
38991 }
38992
38993
38994 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38995 PyObject *resultobj = 0;
38996 wxMenu *arg1 = (wxMenu *) 0 ;
38997 int arg2 ;
38998 wxString *arg3 = 0 ;
38999 wxString const &arg4_defvalue = wxPyEmptyString ;
39000 wxString *arg4 = (wxString *) &arg4_defvalue ;
39001 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39002 wxMenuItem *result = 0 ;
39003 void *argp1 = 0 ;
39004 int res1 = 0 ;
39005 int val2 ;
39006 int ecode2 = 0 ;
39007 bool temp3 = false ;
39008 bool temp4 = false ;
39009 int val5 ;
39010 int ecode5 = 0 ;
39011 PyObject * obj0 = 0 ;
39012 PyObject * obj1 = 0 ;
39013 PyObject * obj2 = 0 ;
39014 PyObject * obj3 = 0 ;
39015 PyObject * obj4 = 0 ;
39016 char * kwnames[] = {
39017 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39018 };
39019
39020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39022 if (!SWIG_IsOK(res1)) {
39023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39024 }
39025 arg1 = reinterpret_cast< wxMenu * >(argp1);
39026 ecode2 = SWIG_AsVal_int(obj1, &val2);
39027 if (!SWIG_IsOK(ecode2)) {
39028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39029 }
39030 arg2 = static_cast< int >(val2);
39031 {
39032 arg3 = wxString_in_helper(obj2);
39033 if (arg3 == NULL) SWIG_fail;
39034 temp3 = true;
39035 }
39036 if (obj3) {
39037 {
39038 arg4 = wxString_in_helper(obj3);
39039 if (arg4 == NULL) SWIG_fail;
39040 temp4 = true;
39041 }
39042 }
39043 if (obj4) {
39044 ecode5 = SWIG_AsVal_int(obj4, &val5);
39045 if (!SWIG_IsOK(ecode5)) {
39046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39047 }
39048 arg5 = static_cast< wxItemKind >(val5);
39049 }
39050 {
39051 PyThreadState* __tstate = wxPyBeginAllowThreads();
39052 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39053 wxPyEndAllowThreads(__tstate);
39054 if (PyErr_Occurred()) SWIG_fail;
39055 }
39056 {
39057 resultobj = wxPyMake_wxObject(result, (bool)0);
39058 }
39059 {
39060 if (temp3)
39061 delete arg3;
39062 }
39063 {
39064 if (temp4)
39065 delete arg4;
39066 }
39067 return resultobj;
39068 fail:
39069 {
39070 if (temp3)
39071 delete arg3;
39072 }
39073 {
39074 if (temp4)
39075 delete arg4;
39076 }
39077 return NULL;
39078 }
39079
39080
39081 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39082 PyObject *resultobj = 0;
39083 wxMenu *arg1 = (wxMenu *) 0 ;
39084 wxMenuItem *result = 0 ;
39085 void *argp1 = 0 ;
39086 int res1 = 0 ;
39087 PyObject *swig_obj[1] ;
39088
39089 if (!args) SWIG_fail;
39090 swig_obj[0] = args;
39091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39092 if (!SWIG_IsOK(res1)) {
39093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39094 }
39095 arg1 = reinterpret_cast< wxMenu * >(argp1);
39096 {
39097 PyThreadState* __tstate = wxPyBeginAllowThreads();
39098 result = (wxMenuItem *)(arg1)->PrependSeparator();
39099 wxPyEndAllowThreads(__tstate);
39100 if (PyErr_Occurred()) SWIG_fail;
39101 }
39102 {
39103 resultobj = wxPyMake_wxObject(result, (bool)0);
39104 }
39105 return resultobj;
39106 fail:
39107 return NULL;
39108 }
39109
39110
39111 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39112 PyObject *resultobj = 0;
39113 wxMenu *arg1 = (wxMenu *) 0 ;
39114 int arg2 ;
39115 wxString *arg3 = 0 ;
39116 wxString const &arg4_defvalue = wxPyEmptyString ;
39117 wxString *arg4 = (wxString *) &arg4_defvalue ;
39118 wxMenuItem *result = 0 ;
39119 void *argp1 = 0 ;
39120 int res1 = 0 ;
39121 int val2 ;
39122 int ecode2 = 0 ;
39123 bool temp3 = false ;
39124 bool temp4 = false ;
39125 PyObject * obj0 = 0 ;
39126 PyObject * obj1 = 0 ;
39127 PyObject * obj2 = 0 ;
39128 PyObject * obj3 = 0 ;
39129 char * kwnames[] = {
39130 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39131 };
39132
39133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39135 if (!SWIG_IsOK(res1)) {
39136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39137 }
39138 arg1 = reinterpret_cast< wxMenu * >(argp1);
39139 ecode2 = SWIG_AsVal_int(obj1, &val2);
39140 if (!SWIG_IsOK(ecode2)) {
39141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39142 }
39143 arg2 = static_cast< int >(val2);
39144 {
39145 arg3 = wxString_in_helper(obj2);
39146 if (arg3 == NULL) SWIG_fail;
39147 temp3 = true;
39148 }
39149 if (obj3) {
39150 {
39151 arg4 = wxString_in_helper(obj3);
39152 if (arg4 == NULL) SWIG_fail;
39153 temp4 = true;
39154 }
39155 }
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 {
39163 resultobj = wxPyMake_wxObject(result, (bool)0);
39164 }
39165 {
39166 if (temp3)
39167 delete arg3;
39168 }
39169 {
39170 if (temp4)
39171 delete arg4;
39172 }
39173 return resultobj;
39174 fail:
39175 {
39176 if (temp3)
39177 delete arg3;
39178 }
39179 {
39180 if (temp4)
39181 delete arg4;
39182 }
39183 return NULL;
39184 }
39185
39186
39187 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39188 PyObject *resultobj = 0;
39189 wxMenu *arg1 = (wxMenu *) 0 ;
39190 int arg2 ;
39191 wxString *arg3 = 0 ;
39192 wxString const &arg4_defvalue = wxPyEmptyString ;
39193 wxString *arg4 = (wxString *) &arg4_defvalue ;
39194 wxMenuItem *result = 0 ;
39195 void *argp1 = 0 ;
39196 int res1 = 0 ;
39197 int val2 ;
39198 int ecode2 = 0 ;
39199 bool temp3 = false ;
39200 bool temp4 = false ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 PyObject * obj2 = 0 ;
39204 PyObject * obj3 = 0 ;
39205 char * kwnames[] = {
39206 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39207 };
39208
39209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39211 if (!SWIG_IsOK(res1)) {
39212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39213 }
39214 arg1 = reinterpret_cast< wxMenu * >(argp1);
39215 ecode2 = SWIG_AsVal_int(obj1, &val2);
39216 if (!SWIG_IsOK(ecode2)) {
39217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39218 }
39219 arg2 = static_cast< int >(val2);
39220 {
39221 arg3 = wxString_in_helper(obj2);
39222 if (arg3 == NULL) SWIG_fail;
39223 temp3 = true;
39224 }
39225 if (obj3) {
39226 {
39227 arg4 = wxString_in_helper(obj3);
39228 if (arg4 == NULL) SWIG_fail;
39229 temp4 = true;
39230 }
39231 }
39232 {
39233 PyThreadState* __tstate = wxPyBeginAllowThreads();
39234 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, (bool)0);
39240 }
39241 {
39242 if (temp3)
39243 delete arg3;
39244 }
39245 {
39246 if (temp4)
39247 delete arg4;
39248 }
39249 return resultobj;
39250 fail:
39251 {
39252 if (temp3)
39253 delete arg3;
39254 }
39255 {
39256 if (temp4)
39257 delete arg4;
39258 }
39259 return NULL;
39260 }
39261
39262
39263 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj = 0;
39265 wxMenu *arg1 = (wxMenu *) 0 ;
39266 int arg2 ;
39267 wxString *arg3 = 0 ;
39268 wxMenu *arg4 = (wxMenu *) 0 ;
39269 wxString const &arg5_defvalue = wxPyEmptyString ;
39270 wxString *arg5 = (wxString *) &arg5_defvalue ;
39271 wxMenuItem *result = 0 ;
39272 void *argp1 = 0 ;
39273 int res1 = 0 ;
39274 int val2 ;
39275 int ecode2 = 0 ;
39276 bool temp3 = false ;
39277 void *argp4 = 0 ;
39278 int res4 = 0 ;
39279 bool temp5 = false ;
39280 PyObject * obj0 = 0 ;
39281 PyObject * obj1 = 0 ;
39282 PyObject * obj2 = 0 ;
39283 PyObject * obj3 = 0 ;
39284 PyObject * obj4 = 0 ;
39285 char * kwnames[] = {
39286 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39287 };
39288
39289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39291 if (!SWIG_IsOK(res1)) {
39292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39293 }
39294 arg1 = reinterpret_cast< wxMenu * >(argp1);
39295 ecode2 = SWIG_AsVal_int(obj1, &val2);
39296 if (!SWIG_IsOK(ecode2)) {
39297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39298 }
39299 arg2 = static_cast< int >(val2);
39300 {
39301 arg3 = wxString_in_helper(obj2);
39302 if (arg3 == NULL) SWIG_fail;
39303 temp3 = true;
39304 }
39305 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39306 if (!SWIG_IsOK(res4)) {
39307 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39308 }
39309 arg4 = reinterpret_cast< wxMenu * >(argp4);
39310 if (obj4) {
39311 {
39312 arg5 = wxString_in_helper(obj4);
39313 if (arg5 == NULL) SWIG_fail;
39314 temp5 = true;
39315 }
39316 }
39317 {
39318 PyThreadState* __tstate = wxPyBeginAllowThreads();
39319 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39320 wxPyEndAllowThreads(__tstate);
39321 if (PyErr_Occurred()) SWIG_fail;
39322 }
39323 {
39324 resultobj = wxPyMake_wxObject(result, (bool)0);
39325 }
39326 {
39327 if (temp3)
39328 delete arg3;
39329 }
39330 {
39331 if (temp5)
39332 delete arg5;
39333 }
39334 return resultobj;
39335 fail:
39336 {
39337 if (temp3)
39338 delete arg3;
39339 }
39340 {
39341 if (temp5)
39342 delete arg5;
39343 }
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39349 PyObject *resultobj = 0;
39350 wxMenu *arg1 = (wxMenu *) 0 ;
39351 int arg2 ;
39352 wxMenuItem *result = 0 ;
39353 void *argp1 = 0 ;
39354 int res1 = 0 ;
39355 int val2 ;
39356 int ecode2 = 0 ;
39357 PyObject * obj0 = 0 ;
39358 PyObject * obj1 = 0 ;
39359 char * kwnames[] = {
39360 (char *) "self",(char *) "id", NULL
39361 };
39362
39363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39365 if (!SWIG_IsOK(res1)) {
39366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39367 }
39368 arg1 = reinterpret_cast< wxMenu * >(argp1);
39369 ecode2 = SWIG_AsVal_int(obj1, &val2);
39370 if (!SWIG_IsOK(ecode2)) {
39371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39372 }
39373 arg2 = static_cast< int >(val2);
39374 {
39375 PyThreadState* __tstate = wxPyBeginAllowThreads();
39376 result = (wxMenuItem *)(arg1)->Remove(arg2);
39377 wxPyEndAllowThreads(__tstate);
39378 if (PyErr_Occurred()) SWIG_fail;
39379 }
39380 {
39381 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39382 }
39383 return resultobj;
39384 fail:
39385 return NULL;
39386 }
39387
39388
39389 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39390 PyObject *resultobj = 0;
39391 wxMenu *arg1 = (wxMenu *) 0 ;
39392 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39393 wxMenuItem *result = 0 ;
39394 void *argp1 = 0 ;
39395 int res1 = 0 ;
39396 void *argp2 = 0 ;
39397 int res2 = 0 ;
39398 PyObject * obj0 = 0 ;
39399 PyObject * obj1 = 0 ;
39400 char * kwnames[] = {
39401 (char *) "self",(char *) "item", NULL
39402 };
39403
39404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39406 if (!SWIG_IsOK(res1)) {
39407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39408 }
39409 arg1 = reinterpret_cast< wxMenu * >(argp1);
39410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39411 if (!SWIG_IsOK(res2)) {
39412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39413 }
39414 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 result = (wxMenuItem *)(arg1)->Remove(arg2);
39418 wxPyEndAllowThreads(__tstate);
39419 if (PyErr_Occurred()) SWIG_fail;
39420 }
39421 {
39422 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39423 }
39424 return resultobj;
39425 fail:
39426 return NULL;
39427 }
39428
39429
39430 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39431 PyObject *resultobj = 0;
39432 wxMenu *arg1 = (wxMenu *) 0 ;
39433 int arg2 ;
39434 bool result;
39435 void *argp1 = 0 ;
39436 int res1 = 0 ;
39437 int val2 ;
39438 int ecode2 = 0 ;
39439 PyObject * obj0 = 0 ;
39440 PyObject * obj1 = 0 ;
39441 char * kwnames[] = {
39442 (char *) "self",(char *) "id", NULL
39443 };
39444
39445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39447 if (!SWIG_IsOK(res1)) {
39448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39449 }
39450 arg1 = reinterpret_cast< wxMenu * >(argp1);
39451 ecode2 = SWIG_AsVal_int(obj1, &val2);
39452 if (!SWIG_IsOK(ecode2)) {
39453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39454 }
39455 arg2 = static_cast< int >(val2);
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (bool)(arg1)->Delete(arg2);
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 {
39463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39464 }
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj = 0;
39473 wxMenu *arg1 = (wxMenu *) 0 ;
39474 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39475 bool result;
39476 void *argp1 = 0 ;
39477 int res1 = 0 ;
39478 void *argp2 = 0 ;
39479 int res2 = 0 ;
39480 PyObject * obj0 = 0 ;
39481 PyObject * obj1 = 0 ;
39482 char * kwnames[] = {
39483 (char *) "self",(char *) "item", NULL
39484 };
39485
39486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39488 if (!SWIG_IsOK(res1)) {
39489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39490 }
39491 arg1 = reinterpret_cast< wxMenu * >(argp1);
39492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39493 if (!SWIG_IsOK(res2)) {
39494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39495 }
39496 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39497 {
39498 PyThreadState* __tstate = wxPyBeginAllowThreads();
39499 result = (bool)(arg1)->Delete(arg2);
39500 wxPyEndAllowThreads(__tstate);
39501 if (PyErr_Occurred()) SWIG_fail;
39502 }
39503 {
39504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39505 }
39506 return resultobj;
39507 fail:
39508 return NULL;
39509 }
39510
39511
39512 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39513 PyObject *resultobj = 0;
39514 wxMenu *arg1 = (wxMenu *) 0 ;
39515 void *argp1 = 0 ;
39516 int res1 = 0 ;
39517 PyObject *swig_obj[1] ;
39518
39519 if (!args) SWIG_fail;
39520 swig_obj[0] = args;
39521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39522 if (!SWIG_IsOK(res1)) {
39523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39524 }
39525 arg1 = reinterpret_cast< wxMenu * >(argp1);
39526 {
39527 PyThreadState* __tstate = wxPyBeginAllowThreads();
39528 wxMenu_Destroy(arg1);
39529 wxPyEndAllowThreads(__tstate);
39530 if (PyErr_Occurred()) SWIG_fail;
39531 }
39532 resultobj = SWIG_Py_Void();
39533 return resultobj;
39534 fail:
39535 return NULL;
39536 }
39537
39538
39539 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39540 PyObject *resultobj = 0;
39541 wxMenu *arg1 = (wxMenu *) 0 ;
39542 int arg2 ;
39543 bool result;
39544 void *argp1 = 0 ;
39545 int res1 = 0 ;
39546 int val2 ;
39547 int ecode2 = 0 ;
39548 PyObject * obj0 = 0 ;
39549 PyObject * obj1 = 0 ;
39550 char * kwnames[] = {
39551 (char *) "self",(char *) "id", NULL
39552 };
39553
39554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39556 if (!SWIG_IsOK(res1)) {
39557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39558 }
39559 arg1 = reinterpret_cast< wxMenu * >(argp1);
39560 ecode2 = SWIG_AsVal_int(obj1, &val2);
39561 if (!SWIG_IsOK(ecode2)) {
39562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39563 }
39564 arg2 = static_cast< int >(val2);
39565 {
39566 PyThreadState* __tstate = wxPyBeginAllowThreads();
39567 result = (bool)(arg1)->Destroy(arg2);
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 {
39572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39573 }
39574 return resultobj;
39575 fail:
39576 return NULL;
39577 }
39578
39579
39580 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39581 PyObject *resultobj = 0;
39582 wxMenu *arg1 = (wxMenu *) 0 ;
39583 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39584 bool result;
39585 void *argp1 = 0 ;
39586 int res1 = 0 ;
39587 void *argp2 = 0 ;
39588 int res2 = 0 ;
39589 PyObject * obj0 = 0 ;
39590 PyObject * obj1 = 0 ;
39591 char * kwnames[] = {
39592 (char *) "self",(char *) "item", NULL
39593 };
39594
39595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39597 if (!SWIG_IsOK(res1)) {
39598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39599 }
39600 arg1 = reinterpret_cast< wxMenu * >(argp1);
39601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39602 if (!SWIG_IsOK(res2)) {
39603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39604 }
39605 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39606 {
39607 PyThreadState* __tstate = wxPyBeginAllowThreads();
39608 result = (bool)(arg1)->Destroy(arg2);
39609 wxPyEndAllowThreads(__tstate);
39610 if (PyErr_Occurred()) SWIG_fail;
39611 }
39612 {
39613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39614 }
39615 return resultobj;
39616 fail:
39617 return NULL;
39618 }
39619
39620
39621 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39622 PyObject *resultobj = 0;
39623 wxMenu *arg1 = (wxMenu *) 0 ;
39624 size_t result;
39625 void *argp1 = 0 ;
39626 int res1 = 0 ;
39627 PyObject *swig_obj[1] ;
39628
39629 if (!args) SWIG_fail;
39630 swig_obj[0] = args;
39631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39632 if (!SWIG_IsOK(res1)) {
39633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39634 }
39635 arg1 = reinterpret_cast< wxMenu * >(argp1);
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39643 return resultobj;
39644 fail:
39645 return NULL;
39646 }
39647
39648
39649 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39650 PyObject *resultobj = 0;
39651 wxMenu *arg1 = (wxMenu *) 0 ;
39652 PyObject *result = 0 ;
39653 void *argp1 = 0 ;
39654 int res1 = 0 ;
39655 PyObject *swig_obj[1] ;
39656
39657 if (!args) SWIG_fail;
39658 swig_obj[0] = args;
39659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39660 if (!SWIG_IsOK(res1)) {
39661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39662 }
39663 arg1 = reinterpret_cast< wxMenu * >(argp1);
39664 {
39665 PyThreadState* __tstate = wxPyBeginAllowThreads();
39666 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39667 wxPyEndAllowThreads(__tstate);
39668 if (PyErr_Occurred()) SWIG_fail;
39669 }
39670 resultobj = result;
39671 return resultobj;
39672 fail:
39673 return NULL;
39674 }
39675
39676
39677 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39678 PyObject *resultobj = 0;
39679 wxMenu *arg1 = (wxMenu *) 0 ;
39680 wxString *arg2 = 0 ;
39681 int result;
39682 void *argp1 = 0 ;
39683 int res1 = 0 ;
39684 bool temp2 = false ;
39685 PyObject * obj0 = 0 ;
39686 PyObject * obj1 = 0 ;
39687 char * kwnames[] = {
39688 (char *) "self",(char *) "item", NULL
39689 };
39690
39691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39693 if (!SWIG_IsOK(res1)) {
39694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39695 }
39696 arg1 = reinterpret_cast< wxMenu * >(argp1);
39697 {
39698 arg2 = wxString_in_helper(obj1);
39699 if (arg2 == NULL) SWIG_fail;
39700 temp2 = true;
39701 }
39702 {
39703 PyThreadState* __tstate = wxPyBeginAllowThreads();
39704 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39705 wxPyEndAllowThreads(__tstate);
39706 if (PyErr_Occurred()) SWIG_fail;
39707 }
39708 resultobj = SWIG_From_int(static_cast< int >(result));
39709 {
39710 if (temp2)
39711 delete arg2;
39712 }
39713 return resultobj;
39714 fail:
39715 {
39716 if (temp2)
39717 delete arg2;
39718 }
39719 return NULL;
39720 }
39721
39722
39723 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39724 PyObject *resultobj = 0;
39725 wxMenu *arg1 = (wxMenu *) 0 ;
39726 int arg2 ;
39727 wxMenuItem *result = 0 ;
39728 void *argp1 = 0 ;
39729 int res1 = 0 ;
39730 int val2 ;
39731 int ecode2 = 0 ;
39732 PyObject * obj0 = 0 ;
39733 PyObject * obj1 = 0 ;
39734 char * kwnames[] = {
39735 (char *) "self",(char *) "id", NULL
39736 };
39737
39738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39740 if (!SWIG_IsOK(res1)) {
39741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39742 }
39743 arg1 = reinterpret_cast< wxMenu * >(argp1);
39744 ecode2 = SWIG_AsVal_int(obj1, &val2);
39745 if (!SWIG_IsOK(ecode2)) {
39746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39747 }
39748 arg2 = static_cast< int >(val2);
39749 {
39750 PyThreadState* __tstate = wxPyBeginAllowThreads();
39751 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39752 wxPyEndAllowThreads(__tstate);
39753 if (PyErr_Occurred()) SWIG_fail;
39754 }
39755 {
39756 resultobj = wxPyMake_wxObject(result, (bool)0);
39757 }
39758 return resultobj;
39759 fail:
39760 return NULL;
39761 }
39762
39763
39764 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39765 PyObject *resultobj = 0;
39766 wxMenu *arg1 = (wxMenu *) 0 ;
39767 size_t arg2 ;
39768 wxMenuItem *result = 0 ;
39769 void *argp1 = 0 ;
39770 int res1 = 0 ;
39771 size_t val2 ;
39772 int ecode2 = 0 ;
39773 PyObject * obj0 = 0 ;
39774 PyObject * obj1 = 0 ;
39775 char * kwnames[] = {
39776 (char *) "self",(char *) "position", NULL
39777 };
39778
39779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39781 if (!SWIG_IsOK(res1)) {
39782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39783 }
39784 arg1 = reinterpret_cast< wxMenu * >(argp1);
39785 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39786 if (!SWIG_IsOK(ecode2)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39788 }
39789 arg2 = static_cast< size_t >(val2);
39790 {
39791 PyThreadState* __tstate = wxPyBeginAllowThreads();
39792 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 {
39797 resultobj = wxPyMake_wxObject(result, (bool)0);
39798 }
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj = 0;
39807 wxMenu *arg1 = (wxMenu *) 0 ;
39808 int arg2 ;
39809 bool arg3 ;
39810 void *argp1 = 0 ;
39811 int res1 = 0 ;
39812 int val2 ;
39813 int ecode2 = 0 ;
39814 bool val3 ;
39815 int ecode3 = 0 ;
39816 PyObject * obj0 = 0 ;
39817 PyObject * obj1 = 0 ;
39818 PyObject * obj2 = 0 ;
39819 char * kwnames[] = {
39820 (char *) "self",(char *) "id",(char *) "enable", NULL
39821 };
39822
39823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39825 if (!SWIG_IsOK(res1)) {
39826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39827 }
39828 arg1 = reinterpret_cast< wxMenu * >(argp1);
39829 ecode2 = SWIG_AsVal_int(obj1, &val2);
39830 if (!SWIG_IsOK(ecode2)) {
39831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39832 }
39833 arg2 = static_cast< int >(val2);
39834 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39835 if (!SWIG_IsOK(ecode3)) {
39836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39837 }
39838 arg3 = static_cast< bool >(val3);
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 (arg1)->Enable(arg2,arg3);
39842 wxPyEndAllowThreads(__tstate);
39843 if (PyErr_Occurred()) SWIG_fail;
39844 }
39845 resultobj = SWIG_Py_Void();
39846 return resultobj;
39847 fail:
39848 return NULL;
39849 }
39850
39851
39852 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39853 PyObject *resultobj = 0;
39854 wxMenu *arg1 = (wxMenu *) 0 ;
39855 int arg2 ;
39856 bool result;
39857 void *argp1 = 0 ;
39858 int res1 = 0 ;
39859 int val2 ;
39860 int ecode2 = 0 ;
39861 PyObject * obj0 = 0 ;
39862 PyObject * obj1 = 0 ;
39863 char * kwnames[] = {
39864 (char *) "self",(char *) "id", NULL
39865 };
39866
39867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39869 if (!SWIG_IsOK(res1)) {
39870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39871 }
39872 arg1 = reinterpret_cast< wxMenu * >(argp1);
39873 ecode2 = SWIG_AsVal_int(obj1, &val2);
39874 if (!SWIG_IsOK(ecode2)) {
39875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39876 }
39877 arg2 = static_cast< int >(val2);
39878 {
39879 PyThreadState* __tstate = wxPyBeginAllowThreads();
39880 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39881 wxPyEndAllowThreads(__tstate);
39882 if (PyErr_Occurred()) SWIG_fail;
39883 }
39884 {
39885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39886 }
39887 return resultobj;
39888 fail:
39889 return NULL;
39890 }
39891
39892
39893 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39894 PyObject *resultobj = 0;
39895 wxMenu *arg1 = (wxMenu *) 0 ;
39896 int arg2 ;
39897 bool arg3 ;
39898 void *argp1 = 0 ;
39899 int res1 = 0 ;
39900 int val2 ;
39901 int ecode2 = 0 ;
39902 bool val3 ;
39903 int ecode3 = 0 ;
39904 PyObject * obj0 = 0 ;
39905 PyObject * obj1 = 0 ;
39906 PyObject * obj2 = 0 ;
39907 char * kwnames[] = {
39908 (char *) "self",(char *) "id",(char *) "check", NULL
39909 };
39910
39911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39913 if (!SWIG_IsOK(res1)) {
39914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39915 }
39916 arg1 = reinterpret_cast< wxMenu * >(argp1);
39917 ecode2 = SWIG_AsVal_int(obj1, &val2);
39918 if (!SWIG_IsOK(ecode2)) {
39919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39920 }
39921 arg2 = static_cast< int >(val2);
39922 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39923 if (!SWIG_IsOK(ecode3)) {
39924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39925 }
39926 arg3 = static_cast< bool >(val3);
39927 {
39928 PyThreadState* __tstate = wxPyBeginAllowThreads();
39929 (arg1)->Check(arg2,arg3);
39930 wxPyEndAllowThreads(__tstate);
39931 if (PyErr_Occurred()) SWIG_fail;
39932 }
39933 resultobj = SWIG_Py_Void();
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39941 PyObject *resultobj = 0;
39942 wxMenu *arg1 = (wxMenu *) 0 ;
39943 int arg2 ;
39944 bool result;
39945 void *argp1 = 0 ;
39946 int res1 = 0 ;
39947 int val2 ;
39948 int ecode2 = 0 ;
39949 PyObject * obj0 = 0 ;
39950 PyObject * obj1 = 0 ;
39951 char * kwnames[] = {
39952 (char *) "self",(char *) "id", NULL
39953 };
39954
39955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39957 if (!SWIG_IsOK(res1)) {
39958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39959 }
39960 arg1 = reinterpret_cast< wxMenu * >(argp1);
39961 ecode2 = SWIG_AsVal_int(obj1, &val2);
39962 if (!SWIG_IsOK(ecode2)) {
39963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39964 }
39965 arg2 = static_cast< int >(val2);
39966 {
39967 PyThreadState* __tstate = wxPyBeginAllowThreads();
39968 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39969 wxPyEndAllowThreads(__tstate);
39970 if (PyErr_Occurred()) SWIG_fail;
39971 }
39972 {
39973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39974 }
39975 return resultobj;
39976 fail:
39977 return NULL;
39978 }
39979
39980
39981 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39982 PyObject *resultobj = 0;
39983 wxMenu *arg1 = (wxMenu *) 0 ;
39984 int arg2 ;
39985 wxString *arg3 = 0 ;
39986 void *argp1 = 0 ;
39987 int res1 = 0 ;
39988 int val2 ;
39989 int ecode2 = 0 ;
39990 bool temp3 = false ;
39991 PyObject * obj0 = 0 ;
39992 PyObject * obj1 = 0 ;
39993 PyObject * obj2 = 0 ;
39994 char * kwnames[] = {
39995 (char *) "self",(char *) "id",(char *) "label", NULL
39996 };
39997
39998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40000 if (!SWIG_IsOK(res1)) {
40001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40002 }
40003 arg1 = reinterpret_cast< wxMenu * >(argp1);
40004 ecode2 = SWIG_AsVal_int(obj1, &val2);
40005 if (!SWIG_IsOK(ecode2)) {
40006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40007 }
40008 arg2 = static_cast< int >(val2);
40009 {
40010 arg3 = wxString_in_helper(obj2);
40011 if (arg3 == NULL) SWIG_fail;
40012 temp3 = true;
40013 }
40014 {
40015 PyThreadState* __tstate = wxPyBeginAllowThreads();
40016 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40017 wxPyEndAllowThreads(__tstate);
40018 if (PyErr_Occurred()) SWIG_fail;
40019 }
40020 resultobj = SWIG_Py_Void();
40021 {
40022 if (temp3)
40023 delete arg3;
40024 }
40025 return resultobj;
40026 fail:
40027 {
40028 if (temp3)
40029 delete arg3;
40030 }
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40036 PyObject *resultobj = 0;
40037 wxMenu *arg1 = (wxMenu *) 0 ;
40038 int arg2 ;
40039 wxString result;
40040 void *argp1 = 0 ;
40041 int res1 = 0 ;
40042 int val2 ;
40043 int ecode2 = 0 ;
40044 PyObject * obj0 = 0 ;
40045 PyObject * obj1 = 0 ;
40046 char * kwnames[] = {
40047 (char *) "self",(char *) "id", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40054 }
40055 arg1 = reinterpret_cast< wxMenu * >(argp1);
40056 ecode2 = SWIG_AsVal_int(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40059 }
40060 arg2 = static_cast< int >(val2);
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40064 wxPyEndAllowThreads(__tstate);
40065 if (PyErr_Occurred()) SWIG_fail;
40066 }
40067 {
40068 #if wxUSE_UNICODE
40069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40070 #else
40071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40072 #endif
40073 }
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj = 0;
40082 wxMenu *arg1 = (wxMenu *) 0 ;
40083 int arg2 ;
40084 wxString *arg3 = 0 ;
40085 void *argp1 = 0 ;
40086 int res1 = 0 ;
40087 int val2 ;
40088 int ecode2 = 0 ;
40089 bool temp3 = false ;
40090 PyObject * obj0 = 0 ;
40091 PyObject * obj1 = 0 ;
40092 PyObject * obj2 = 0 ;
40093 char * kwnames[] = {
40094 (char *) "self",(char *) "id",(char *) "helpString", NULL
40095 };
40096
40097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40099 if (!SWIG_IsOK(res1)) {
40100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40101 }
40102 arg1 = reinterpret_cast< wxMenu * >(argp1);
40103 ecode2 = SWIG_AsVal_int(obj1, &val2);
40104 if (!SWIG_IsOK(ecode2)) {
40105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40106 }
40107 arg2 = static_cast< int >(val2);
40108 {
40109 arg3 = wxString_in_helper(obj2);
40110 if (arg3 == NULL) SWIG_fail;
40111 temp3 = true;
40112 }
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 resultobj = SWIG_Py_Void();
40120 {
40121 if (temp3)
40122 delete arg3;
40123 }
40124 return resultobj;
40125 fail:
40126 {
40127 if (temp3)
40128 delete arg3;
40129 }
40130 return NULL;
40131 }
40132
40133
40134 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40135 PyObject *resultobj = 0;
40136 wxMenu *arg1 = (wxMenu *) 0 ;
40137 int arg2 ;
40138 wxString result;
40139 void *argp1 = 0 ;
40140 int res1 = 0 ;
40141 int val2 ;
40142 int ecode2 = 0 ;
40143 PyObject * obj0 = 0 ;
40144 PyObject * obj1 = 0 ;
40145 char * kwnames[] = {
40146 (char *) "self",(char *) "id", NULL
40147 };
40148
40149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40151 if (!SWIG_IsOK(res1)) {
40152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40153 }
40154 arg1 = reinterpret_cast< wxMenu * >(argp1);
40155 ecode2 = SWIG_AsVal_int(obj1, &val2);
40156 if (!SWIG_IsOK(ecode2)) {
40157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40158 }
40159 arg2 = static_cast< int >(val2);
40160 {
40161 PyThreadState* __tstate = wxPyBeginAllowThreads();
40162 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40163 wxPyEndAllowThreads(__tstate);
40164 if (PyErr_Occurred()) SWIG_fail;
40165 }
40166 {
40167 #if wxUSE_UNICODE
40168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40169 #else
40170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40171 #endif
40172 }
40173 return resultobj;
40174 fail:
40175 return NULL;
40176 }
40177
40178
40179 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40180 PyObject *resultobj = 0;
40181 wxMenu *arg1 = (wxMenu *) 0 ;
40182 wxString *arg2 = 0 ;
40183 void *argp1 = 0 ;
40184 int res1 = 0 ;
40185 bool temp2 = false ;
40186 PyObject * obj0 = 0 ;
40187 PyObject * obj1 = 0 ;
40188 char * kwnames[] = {
40189 (char *) "self",(char *) "title", NULL
40190 };
40191
40192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40194 if (!SWIG_IsOK(res1)) {
40195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40196 }
40197 arg1 = reinterpret_cast< wxMenu * >(argp1);
40198 {
40199 arg2 = wxString_in_helper(obj1);
40200 if (arg2 == NULL) SWIG_fail;
40201 temp2 = true;
40202 }
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 (arg1)->SetTitle((wxString const &)*arg2);
40206 wxPyEndAllowThreads(__tstate);
40207 if (PyErr_Occurred()) SWIG_fail;
40208 }
40209 resultobj = SWIG_Py_Void();
40210 {
40211 if (temp2)
40212 delete arg2;
40213 }
40214 return resultobj;
40215 fail:
40216 {
40217 if (temp2)
40218 delete arg2;
40219 }
40220 return NULL;
40221 }
40222
40223
40224 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40225 PyObject *resultobj = 0;
40226 wxMenu *arg1 = (wxMenu *) 0 ;
40227 wxString result;
40228 void *argp1 = 0 ;
40229 int res1 = 0 ;
40230 PyObject *swig_obj[1] ;
40231
40232 if (!args) SWIG_fail;
40233 swig_obj[0] = args;
40234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40235 if (!SWIG_IsOK(res1)) {
40236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40237 }
40238 arg1 = reinterpret_cast< wxMenu * >(argp1);
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = ((wxMenu const *)arg1)->GetTitle();
40242 wxPyEndAllowThreads(__tstate);
40243 if (PyErr_Occurred()) SWIG_fail;
40244 }
40245 {
40246 #if wxUSE_UNICODE
40247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40248 #else
40249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40250 #endif
40251 }
40252 return resultobj;
40253 fail:
40254 return NULL;
40255 }
40256
40257
40258 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40259 PyObject *resultobj = 0;
40260 wxMenu *arg1 = (wxMenu *) 0 ;
40261 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40262 void *argp1 = 0 ;
40263 int res1 = 0 ;
40264 void *argp2 = 0 ;
40265 int res2 = 0 ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 char * kwnames[] = {
40269 (char *) "self",(char *) "handler", NULL
40270 };
40271
40272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40274 if (!SWIG_IsOK(res1)) {
40275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40276 }
40277 arg1 = reinterpret_cast< wxMenu * >(argp1);
40278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40279 if (!SWIG_IsOK(res2)) {
40280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40281 }
40282 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40283 {
40284 PyThreadState* __tstate = wxPyBeginAllowThreads();
40285 (arg1)->SetEventHandler(arg2);
40286 wxPyEndAllowThreads(__tstate);
40287 if (PyErr_Occurred()) SWIG_fail;
40288 }
40289 resultobj = SWIG_Py_Void();
40290 return resultobj;
40291 fail:
40292 return NULL;
40293 }
40294
40295
40296 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40297 PyObject *resultobj = 0;
40298 wxMenu *arg1 = (wxMenu *) 0 ;
40299 wxEvtHandler *result = 0 ;
40300 void *argp1 = 0 ;
40301 int res1 = 0 ;
40302 PyObject *swig_obj[1] ;
40303
40304 if (!args) SWIG_fail;
40305 swig_obj[0] = args;
40306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40307 if (!SWIG_IsOK(res1)) {
40308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40309 }
40310 arg1 = reinterpret_cast< wxMenu * >(argp1);
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 {
40318 resultobj = wxPyMake_wxObject(result, 0);
40319 }
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj = 0;
40328 wxMenu *arg1 = (wxMenu *) 0 ;
40329 wxWindow *arg2 = (wxWindow *) 0 ;
40330 void *argp1 = 0 ;
40331 int res1 = 0 ;
40332 void *argp2 = 0 ;
40333 int res2 = 0 ;
40334 PyObject * obj0 = 0 ;
40335 PyObject * obj1 = 0 ;
40336 char * kwnames[] = {
40337 (char *) "self",(char *) "win", NULL
40338 };
40339
40340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40342 if (!SWIG_IsOK(res1)) {
40343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40344 }
40345 arg1 = reinterpret_cast< wxMenu * >(argp1);
40346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40347 if (!SWIG_IsOK(res2)) {
40348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40349 }
40350 arg2 = reinterpret_cast< wxWindow * >(argp2);
40351 {
40352 PyThreadState* __tstate = wxPyBeginAllowThreads();
40353 (arg1)->SetInvokingWindow(arg2);
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 resultobj = SWIG_Py_Void();
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40365 PyObject *resultobj = 0;
40366 wxMenu *arg1 = (wxMenu *) 0 ;
40367 wxWindow *result = 0 ;
40368 void *argp1 = 0 ;
40369 int res1 = 0 ;
40370 PyObject *swig_obj[1] ;
40371
40372 if (!args) SWIG_fail;
40373 swig_obj[0] = args;
40374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40375 if (!SWIG_IsOK(res1)) {
40376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40377 }
40378 arg1 = reinterpret_cast< wxMenu * >(argp1);
40379 {
40380 PyThreadState* __tstate = wxPyBeginAllowThreads();
40381 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 {
40386 resultobj = wxPyMake_wxObject(result, 0);
40387 }
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40395 PyObject *resultobj = 0;
40396 wxMenu *arg1 = (wxMenu *) 0 ;
40397 long result;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 PyObject *swig_obj[1] ;
40401
40402 if (!args) SWIG_fail;
40403 swig_obj[0] = args;
40404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40405 if (!SWIG_IsOK(res1)) {
40406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40407 }
40408 arg1 = reinterpret_cast< wxMenu * >(argp1);
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 result = (long)((wxMenu const *)arg1)->GetStyle();
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 resultobj = SWIG_From_long(static_cast< long >(result));
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40423 PyObject *resultobj = 0;
40424 wxMenu *arg1 = (wxMenu *) 0 ;
40425 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40426 void *argp1 = 0 ;
40427 int res1 = 0 ;
40428 void *argp2 = 0 ;
40429 int res2 = 0 ;
40430 PyObject * obj0 = 0 ;
40431 PyObject * obj1 = 0 ;
40432 char * kwnames[] = {
40433 (char *) "self",(char *) "source", NULL
40434 };
40435
40436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40438 if (!SWIG_IsOK(res1)) {
40439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40440 }
40441 arg1 = reinterpret_cast< wxMenu * >(argp1);
40442 if (obj1) {
40443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40444 if (!SWIG_IsOK(res2)) {
40445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40446 }
40447 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40448 }
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 (arg1)->UpdateUI(arg2);
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 resultobj = SWIG_Py_Void();
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40463 PyObject *resultobj = 0;
40464 wxMenu *arg1 = (wxMenu *) 0 ;
40465 wxMenuBar *result = 0 ;
40466 void *argp1 = 0 ;
40467 int res1 = 0 ;
40468 PyObject *swig_obj[1] ;
40469
40470 if (!args) SWIG_fail;
40471 swig_obj[0] = args;
40472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40473 if (!SWIG_IsOK(res1)) {
40474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40475 }
40476 arg1 = reinterpret_cast< wxMenu * >(argp1);
40477 {
40478 PyThreadState* __tstate = wxPyBeginAllowThreads();
40479 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 {
40484 resultobj = wxPyMake_wxObject(result, (bool)0);
40485 }
40486 return resultobj;
40487 fail:
40488 return NULL;
40489 }
40490
40491
40492 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40493 PyObject *resultobj = 0;
40494 wxMenu *arg1 = (wxMenu *) 0 ;
40495 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40496 void *argp1 = 0 ;
40497 int res1 = 0 ;
40498 void *argp2 = 0 ;
40499 int res2 = 0 ;
40500 PyObject * obj0 = 0 ;
40501 PyObject * obj1 = 0 ;
40502 char * kwnames[] = {
40503 (char *) "self",(char *) "menubar", NULL
40504 };
40505
40506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40508 if (!SWIG_IsOK(res1)) {
40509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40510 }
40511 arg1 = reinterpret_cast< wxMenu * >(argp1);
40512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40513 if (!SWIG_IsOK(res2)) {
40514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40515 }
40516 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 (arg1)->Attach(arg2);
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 resultobj = SWIG_Py_Void();
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40531 PyObject *resultobj = 0;
40532 wxMenu *arg1 = (wxMenu *) 0 ;
40533 void *argp1 = 0 ;
40534 int res1 = 0 ;
40535 PyObject *swig_obj[1] ;
40536
40537 if (!args) SWIG_fail;
40538 swig_obj[0] = args;
40539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40540 if (!SWIG_IsOK(res1)) {
40541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40542 }
40543 arg1 = reinterpret_cast< wxMenu * >(argp1);
40544 {
40545 PyThreadState* __tstate = wxPyBeginAllowThreads();
40546 (arg1)->Detach();
40547 wxPyEndAllowThreads(__tstate);
40548 if (PyErr_Occurred()) SWIG_fail;
40549 }
40550 resultobj = SWIG_Py_Void();
40551 return resultobj;
40552 fail:
40553 return NULL;
40554 }
40555
40556
40557 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40558 PyObject *resultobj = 0;
40559 wxMenu *arg1 = (wxMenu *) 0 ;
40560 bool result;
40561 void *argp1 = 0 ;
40562 int res1 = 0 ;
40563 PyObject *swig_obj[1] ;
40564
40565 if (!args) SWIG_fail;
40566 swig_obj[0] = args;
40567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40568 if (!SWIG_IsOK(res1)) {
40569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40570 }
40571 arg1 = reinterpret_cast< wxMenu * >(argp1);
40572 {
40573 PyThreadState* __tstate = wxPyBeginAllowThreads();
40574 result = (bool)((wxMenu const *)arg1)->IsAttached();
40575 wxPyEndAllowThreads(__tstate);
40576 if (PyErr_Occurred()) SWIG_fail;
40577 }
40578 {
40579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40580 }
40581 return resultobj;
40582 fail:
40583 return NULL;
40584 }
40585
40586
40587 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40588 PyObject *resultobj = 0;
40589 wxMenu *arg1 = (wxMenu *) 0 ;
40590 wxMenu *arg2 = (wxMenu *) 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 *) "parent", NULL
40599 };
40600
40601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",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_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40605 }
40606 arg1 = reinterpret_cast< wxMenu * >(argp1);
40607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40608 if (!SWIG_IsOK(res2)) {
40609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40610 }
40611 arg2 = reinterpret_cast< wxMenu * >(argp2);
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 (arg1)->SetParent(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_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40626 PyObject *resultobj = 0;
40627 wxMenu *arg1 = (wxMenu *) 0 ;
40628 wxMenu *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_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40638 }
40639 arg1 = reinterpret_cast< wxMenu * >(argp1);
40640 {
40641 PyThreadState* __tstate = wxPyBeginAllowThreads();
40642 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
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 *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40656 PyObject *obj;
40657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40659 return SWIG_Py_Void();
40660 }
40661
40662 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40663 return SWIG_Python_InitShadowInstance(args);
40664 }
40665
40666 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40667 PyObject *resultobj = 0;
40668 long arg1 = (long) 0 ;
40669 wxMenuBar *result = 0 ;
40670 long val1 ;
40671 int ecode1 = 0 ;
40672 PyObject * obj0 = 0 ;
40673 char * kwnames[] = {
40674 (char *) "style", NULL
40675 };
40676
40677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40678 if (obj0) {
40679 ecode1 = SWIG_AsVal_long(obj0, &val1);
40680 if (!SWIG_IsOK(ecode1)) {
40681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40682 }
40683 arg1 = static_cast< long >(val1);
40684 }
40685 {
40686 if (!wxPyCheckForApp()) SWIG_fail;
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 result = (wxMenuBar *)new wxMenuBar(arg1);
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40693 return resultobj;
40694 fail:
40695 return NULL;
40696 }
40697
40698
40699 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj = 0;
40701 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40702 wxMenu *arg2 = (wxMenu *) 0 ;
40703 wxString *arg3 = 0 ;
40704 bool result;
40705 void *argp1 = 0 ;
40706 int res1 = 0 ;
40707 void *argp2 = 0 ;
40708 int res2 = 0 ;
40709 bool temp3 = false ;
40710 PyObject * obj0 = 0 ;
40711 PyObject * obj1 = 0 ;
40712 PyObject * obj2 = 0 ;
40713 char * kwnames[] = {
40714 (char *) "self",(char *) "menu",(char *) "title", NULL
40715 };
40716
40717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40719 if (!SWIG_IsOK(res1)) {
40720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40721 }
40722 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res2)) {
40725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40726 }
40727 arg2 = reinterpret_cast< wxMenu * >(argp2);
40728 {
40729 arg3 = wxString_in_helper(obj2);
40730 if (arg3 == NULL) SWIG_fail;
40731 temp3 = true;
40732 }
40733 {
40734 PyThreadState* __tstate = wxPyBeginAllowThreads();
40735 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40736 wxPyEndAllowThreads(__tstate);
40737 if (PyErr_Occurred()) SWIG_fail;
40738 }
40739 {
40740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40741 }
40742 {
40743 if (temp3)
40744 delete arg3;
40745 }
40746 return resultobj;
40747 fail:
40748 {
40749 if (temp3)
40750 delete arg3;
40751 }
40752 return NULL;
40753 }
40754
40755
40756 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40757 PyObject *resultobj = 0;
40758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40759 size_t arg2 ;
40760 wxMenu *arg3 = (wxMenu *) 0 ;
40761 wxString *arg4 = 0 ;
40762 bool result;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 size_t val2 ;
40766 int ecode2 = 0 ;
40767 void *argp3 = 0 ;
40768 int res3 = 0 ;
40769 bool temp4 = false ;
40770 PyObject * obj0 = 0 ;
40771 PyObject * obj1 = 0 ;
40772 PyObject * obj2 = 0 ;
40773 PyObject * obj3 = 0 ;
40774 char * kwnames[] = {
40775 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40776 };
40777
40778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40780 if (!SWIG_IsOK(res1)) {
40781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40782 }
40783 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40784 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40785 if (!SWIG_IsOK(ecode2)) {
40786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40787 }
40788 arg2 = static_cast< size_t >(val2);
40789 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40790 if (!SWIG_IsOK(res3)) {
40791 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40792 }
40793 arg3 = reinterpret_cast< wxMenu * >(argp3);
40794 {
40795 arg4 = wxString_in_helper(obj3);
40796 if (arg4 == NULL) SWIG_fail;
40797 temp4 = true;
40798 }
40799 {
40800 PyThreadState* __tstate = wxPyBeginAllowThreads();
40801 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 {
40806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40807 }
40808 {
40809 if (temp4)
40810 delete arg4;
40811 }
40812 return resultobj;
40813 fail:
40814 {
40815 if (temp4)
40816 delete arg4;
40817 }
40818 return NULL;
40819 }
40820
40821
40822 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40823 PyObject *resultobj = 0;
40824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40825 size_t result;
40826 void *argp1 = 0 ;
40827 int res1 = 0 ;
40828 PyObject *swig_obj[1] ;
40829
40830 if (!args) SWIG_fail;
40831 swig_obj[0] = args;
40832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40833 if (!SWIG_IsOK(res1)) {
40834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40835 }
40836 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40851 PyObject *resultobj = 0;
40852 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40853 size_t arg2 ;
40854 wxMenu *result = 0 ;
40855 void *argp1 = 0 ;
40856 int res1 = 0 ;
40857 size_t val2 ;
40858 int ecode2 = 0 ;
40859 PyObject * obj0 = 0 ;
40860 PyObject * obj1 = 0 ;
40861 char * kwnames[] = {
40862 (char *) "self",(char *) "pos", NULL
40863 };
40864
40865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40867 if (!SWIG_IsOK(res1)) {
40868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40869 }
40870 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40872 if (!SWIG_IsOK(ecode2)) {
40873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40874 }
40875 arg2 = static_cast< size_t >(val2);
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40879 wxPyEndAllowThreads(__tstate);
40880 if (PyErr_Occurred()) SWIG_fail;
40881 }
40882 {
40883 resultobj = wxPyMake_wxObject(result, 0);
40884 }
40885 return resultobj;
40886 fail:
40887 return NULL;
40888 }
40889
40890
40891 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40892 PyObject *resultobj = 0;
40893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40894 size_t arg2 ;
40895 wxMenu *arg3 = (wxMenu *) 0 ;
40896 wxString *arg4 = 0 ;
40897 wxMenu *result = 0 ;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 size_t val2 ;
40901 int ecode2 = 0 ;
40902 void *argp3 = 0 ;
40903 int res3 = 0 ;
40904 bool temp4 = false ;
40905 PyObject * obj0 = 0 ;
40906 PyObject * obj1 = 0 ;
40907 PyObject * obj2 = 0 ;
40908 PyObject * obj3 = 0 ;
40909 char * kwnames[] = {
40910 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40911 };
40912
40913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40915 if (!SWIG_IsOK(res1)) {
40916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40917 }
40918 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40919 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40920 if (!SWIG_IsOK(ecode2)) {
40921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40922 }
40923 arg2 = static_cast< size_t >(val2);
40924 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40925 if (!SWIG_IsOK(res3)) {
40926 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40927 }
40928 arg3 = reinterpret_cast< wxMenu * >(argp3);
40929 {
40930 arg4 = wxString_in_helper(obj3);
40931 if (arg4 == NULL) SWIG_fail;
40932 temp4 = true;
40933 }
40934 {
40935 PyThreadState* __tstate = wxPyBeginAllowThreads();
40936 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40937 wxPyEndAllowThreads(__tstate);
40938 if (PyErr_Occurred()) SWIG_fail;
40939 }
40940 {
40941 resultobj = wxPyMake_wxObject(result, 0);
40942 }
40943 {
40944 if (temp4)
40945 delete arg4;
40946 }
40947 return resultobj;
40948 fail:
40949 {
40950 if (temp4)
40951 delete arg4;
40952 }
40953 return NULL;
40954 }
40955
40956
40957 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40958 PyObject *resultobj = 0;
40959 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40960 size_t arg2 ;
40961 wxMenu *result = 0 ;
40962 void *argp1 = 0 ;
40963 int res1 = 0 ;
40964 size_t val2 ;
40965 int ecode2 = 0 ;
40966 PyObject * obj0 = 0 ;
40967 PyObject * obj1 = 0 ;
40968 char * kwnames[] = {
40969 (char *) "self",(char *) "pos", NULL
40970 };
40971
40972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40974 if (!SWIG_IsOK(res1)) {
40975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40976 }
40977 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40978 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40979 if (!SWIG_IsOK(ecode2)) {
40980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40981 }
40982 arg2 = static_cast< size_t >(val2);
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (wxMenu *)(arg1)->Remove(arg2);
40986 wxPyEndAllowThreads(__tstate);
40987 if (PyErr_Occurred()) SWIG_fail;
40988 }
40989 {
40990 resultobj = wxPyMake_wxObject(result, 0);
40991 }
40992 return resultobj;
40993 fail:
40994 return NULL;
40995 }
40996
40997
40998 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40999 PyObject *resultobj = 0;
41000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41001 size_t arg2 ;
41002 bool arg3 ;
41003 void *argp1 = 0 ;
41004 int res1 = 0 ;
41005 size_t val2 ;
41006 int ecode2 = 0 ;
41007 bool val3 ;
41008 int ecode3 = 0 ;
41009 PyObject * obj0 = 0 ;
41010 PyObject * obj1 = 0 ;
41011 PyObject * obj2 = 0 ;
41012 char * kwnames[] = {
41013 (char *) "self",(char *) "pos",(char *) "enable", NULL
41014 };
41015
41016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41018 if (!SWIG_IsOK(res1)) {
41019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41020 }
41021 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41022 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41023 if (!SWIG_IsOK(ecode2)) {
41024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41025 }
41026 arg2 = static_cast< size_t >(val2);
41027 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41028 if (!SWIG_IsOK(ecode3)) {
41029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41030 }
41031 arg3 = static_cast< bool >(val3);
41032 {
41033 PyThreadState* __tstate = wxPyBeginAllowThreads();
41034 (arg1)->EnableTop(arg2,arg3);
41035 wxPyEndAllowThreads(__tstate);
41036 if (PyErr_Occurred()) SWIG_fail;
41037 }
41038 resultobj = SWIG_Py_Void();
41039 return resultobj;
41040 fail:
41041 return NULL;
41042 }
41043
41044
41045 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41046 PyObject *resultobj = 0;
41047 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41048 size_t arg2 ;
41049 bool result;
41050 void *argp1 = 0 ;
41051 int res1 = 0 ;
41052 size_t val2 ;
41053 int ecode2 = 0 ;
41054 PyObject * obj0 = 0 ;
41055 PyObject * obj1 = 0 ;
41056 char * kwnames[] = {
41057 (char *) "self",(char *) "pos", NULL
41058 };
41059
41060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41062 if (!SWIG_IsOK(res1)) {
41063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41064 }
41065 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41066 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41067 if (!SWIG_IsOK(ecode2)) {
41068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41069 }
41070 arg2 = static_cast< size_t >(val2);
41071 {
41072 PyThreadState* __tstate = wxPyBeginAllowThreads();
41073 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41074 wxPyEndAllowThreads(__tstate);
41075 if (PyErr_Occurred()) SWIG_fail;
41076 }
41077 {
41078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41079 }
41080 return resultobj;
41081 fail:
41082 return NULL;
41083 }
41084
41085
41086 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41087 PyObject *resultobj = 0;
41088 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41089 size_t arg2 ;
41090 wxString *arg3 = 0 ;
41091 void *argp1 = 0 ;
41092 int res1 = 0 ;
41093 size_t val2 ;
41094 int ecode2 = 0 ;
41095 bool temp3 = false ;
41096 PyObject * obj0 = 0 ;
41097 PyObject * obj1 = 0 ;
41098 PyObject * obj2 = 0 ;
41099 char * kwnames[] = {
41100 (char *) "self",(char *) "pos",(char *) "label", NULL
41101 };
41102
41103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41105 if (!SWIG_IsOK(res1)) {
41106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41107 }
41108 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41109 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41110 if (!SWIG_IsOK(ecode2)) {
41111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41112 }
41113 arg2 = static_cast< size_t >(val2);
41114 {
41115 arg3 = wxString_in_helper(obj2);
41116 if (arg3 == NULL) SWIG_fail;
41117 temp3 = true;
41118 }
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 resultobj = SWIG_Py_Void();
41126 {
41127 if (temp3)
41128 delete arg3;
41129 }
41130 return resultobj;
41131 fail:
41132 {
41133 if (temp3)
41134 delete arg3;
41135 }
41136 return NULL;
41137 }
41138
41139
41140 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj = 0;
41142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41143 size_t arg2 ;
41144 wxString result;
41145 void *argp1 = 0 ;
41146 int res1 = 0 ;
41147 size_t val2 ;
41148 int ecode2 = 0 ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 char * kwnames[] = {
41152 (char *) "self",(char *) "pos", NULL
41153 };
41154
41155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41157 if (!SWIG_IsOK(res1)) {
41158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41159 }
41160 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41162 if (!SWIG_IsOK(ecode2)) {
41163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41164 }
41165 arg2 = static_cast< size_t >(val2);
41166 {
41167 PyThreadState* __tstate = wxPyBeginAllowThreads();
41168 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41169 wxPyEndAllowThreads(__tstate);
41170 if (PyErr_Occurred()) SWIG_fail;
41171 }
41172 {
41173 #if wxUSE_UNICODE
41174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41175 #else
41176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41177 #endif
41178 }
41179 return resultobj;
41180 fail:
41181 return NULL;
41182 }
41183
41184
41185 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41186 PyObject *resultobj = 0;
41187 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41188 wxString *arg2 = 0 ;
41189 wxString *arg3 = 0 ;
41190 int result;
41191 void *argp1 = 0 ;
41192 int res1 = 0 ;
41193 bool temp2 = false ;
41194 bool temp3 = false ;
41195 PyObject * obj0 = 0 ;
41196 PyObject * obj1 = 0 ;
41197 PyObject * obj2 = 0 ;
41198 char * kwnames[] = {
41199 (char *) "self",(char *) "menu",(char *) "item", NULL
41200 };
41201
41202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41204 if (!SWIG_IsOK(res1)) {
41205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41206 }
41207 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41208 {
41209 arg2 = wxString_in_helper(obj1);
41210 if (arg2 == NULL) SWIG_fail;
41211 temp2 = true;
41212 }
41213 {
41214 arg3 = wxString_in_helper(obj2);
41215 if (arg3 == NULL) SWIG_fail;
41216 temp3 = true;
41217 }
41218 {
41219 PyThreadState* __tstate = wxPyBeginAllowThreads();
41220 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 resultobj = SWIG_From_int(static_cast< int >(result));
41225 {
41226 if (temp2)
41227 delete arg2;
41228 }
41229 {
41230 if (temp3)
41231 delete arg3;
41232 }
41233 return resultobj;
41234 fail:
41235 {
41236 if (temp2)
41237 delete arg2;
41238 }
41239 {
41240 if (temp3)
41241 delete arg3;
41242 }
41243 return NULL;
41244 }
41245
41246
41247 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41248 PyObject *resultobj = 0;
41249 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41250 int arg2 ;
41251 wxMenuItem *result = 0 ;
41252 void *argp1 = 0 ;
41253 int res1 = 0 ;
41254 int val2 ;
41255 int ecode2 = 0 ;
41256 PyObject * obj0 = 0 ;
41257 PyObject * obj1 = 0 ;
41258 char * kwnames[] = {
41259 (char *) "self",(char *) "id", NULL
41260 };
41261
41262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41264 if (!SWIG_IsOK(res1)) {
41265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41266 }
41267 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41268 ecode2 = SWIG_AsVal_int(obj1, &val2);
41269 if (!SWIG_IsOK(ecode2)) {
41270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41271 }
41272 arg2 = static_cast< int >(val2);
41273 {
41274 PyThreadState* __tstate = wxPyBeginAllowThreads();
41275 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41276 wxPyEndAllowThreads(__tstate);
41277 if (PyErr_Occurred()) SWIG_fail;
41278 }
41279 {
41280 resultobj = wxPyMake_wxObject(result, (bool)0);
41281 }
41282 return resultobj;
41283 fail:
41284 return NULL;
41285 }
41286
41287
41288 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41289 PyObject *resultobj = 0;
41290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41291 wxString *arg2 = 0 ;
41292 int result;
41293 void *argp1 = 0 ;
41294 int res1 = 0 ;
41295 bool temp2 = false ;
41296 PyObject * obj0 = 0 ;
41297 PyObject * obj1 = 0 ;
41298 char * kwnames[] = {
41299 (char *) "self",(char *) "title", NULL
41300 };
41301
41302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41304 if (!SWIG_IsOK(res1)) {
41305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41306 }
41307 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41308 {
41309 arg2 = wxString_in_helper(obj1);
41310 if (arg2 == NULL) SWIG_fail;
41311 temp2 = true;
41312 }
41313 {
41314 PyThreadState* __tstate = wxPyBeginAllowThreads();
41315 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41316 wxPyEndAllowThreads(__tstate);
41317 if (PyErr_Occurred()) SWIG_fail;
41318 }
41319 resultobj = SWIG_From_int(static_cast< int >(result));
41320 {
41321 if (temp2)
41322 delete arg2;
41323 }
41324 return resultobj;
41325 fail:
41326 {
41327 if (temp2)
41328 delete arg2;
41329 }
41330 return NULL;
41331 }
41332
41333
41334 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41335 PyObject *resultobj = 0;
41336 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41337 int arg2 ;
41338 bool arg3 ;
41339 void *argp1 = 0 ;
41340 int res1 = 0 ;
41341 int val2 ;
41342 int ecode2 = 0 ;
41343 bool val3 ;
41344 int ecode3 = 0 ;
41345 PyObject * obj0 = 0 ;
41346 PyObject * obj1 = 0 ;
41347 PyObject * obj2 = 0 ;
41348 char * kwnames[] = {
41349 (char *) "self",(char *) "id",(char *) "enable", NULL
41350 };
41351
41352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41354 if (!SWIG_IsOK(res1)) {
41355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41356 }
41357 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41358 ecode2 = SWIG_AsVal_int(obj1, &val2);
41359 if (!SWIG_IsOK(ecode2)) {
41360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41361 }
41362 arg2 = static_cast< int >(val2);
41363 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41364 if (!SWIG_IsOK(ecode3)) {
41365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41366 }
41367 arg3 = static_cast< bool >(val3);
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 (arg1)->Enable(arg2,arg3);
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 resultobj = SWIG_Py_Void();
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41382 PyObject *resultobj = 0;
41383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41384 int arg2 ;
41385 bool arg3 ;
41386 void *argp1 = 0 ;
41387 int res1 = 0 ;
41388 int val2 ;
41389 int ecode2 = 0 ;
41390 bool val3 ;
41391 int ecode3 = 0 ;
41392 PyObject * obj0 = 0 ;
41393 PyObject * obj1 = 0 ;
41394 PyObject * obj2 = 0 ;
41395 char * kwnames[] = {
41396 (char *) "self",(char *) "id",(char *) "check", NULL
41397 };
41398
41399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41401 if (!SWIG_IsOK(res1)) {
41402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41403 }
41404 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41405 ecode2 = SWIG_AsVal_int(obj1, &val2);
41406 if (!SWIG_IsOK(ecode2)) {
41407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41408 }
41409 arg2 = static_cast< int >(val2);
41410 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41411 if (!SWIG_IsOK(ecode3)) {
41412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41413 }
41414 arg3 = static_cast< bool >(val3);
41415 {
41416 PyThreadState* __tstate = wxPyBeginAllowThreads();
41417 (arg1)->Check(arg2,arg3);
41418 wxPyEndAllowThreads(__tstate);
41419 if (PyErr_Occurred()) SWIG_fail;
41420 }
41421 resultobj = SWIG_Py_Void();
41422 return resultobj;
41423 fail:
41424 return NULL;
41425 }
41426
41427
41428 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41429 PyObject *resultobj = 0;
41430 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41431 int arg2 ;
41432 bool result;
41433 void *argp1 = 0 ;
41434 int res1 = 0 ;
41435 int val2 ;
41436 int ecode2 = 0 ;
41437 PyObject * obj0 = 0 ;
41438 PyObject * obj1 = 0 ;
41439 char * kwnames[] = {
41440 (char *) "self",(char *) "id", NULL
41441 };
41442
41443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41445 if (!SWIG_IsOK(res1)) {
41446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41447 }
41448 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41449 ecode2 = SWIG_AsVal_int(obj1, &val2);
41450 if (!SWIG_IsOK(ecode2)) {
41451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41452 }
41453 arg2 = static_cast< int >(val2);
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41457 wxPyEndAllowThreads(__tstate);
41458 if (PyErr_Occurred()) SWIG_fail;
41459 }
41460 {
41461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41462 }
41463 return resultobj;
41464 fail:
41465 return NULL;
41466 }
41467
41468
41469 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41470 PyObject *resultobj = 0;
41471 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41472 int arg2 ;
41473 bool result;
41474 void *argp1 = 0 ;
41475 int res1 = 0 ;
41476 int val2 ;
41477 int ecode2 = 0 ;
41478 PyObject * obj0 = 0 ;
41479 PyObject * obj1 = 0 ;
41480 char * kwnames[] = {
41481 (char *) "self",(char *) "id", NULL
41482 };
41483
41484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",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_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41488 }
41489 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41490 ecode2 = SWIG_AsVal_int(obj1, &val2);
41491 if (!SWIG_IsOK(ecode2)) {
41492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41493 }
41494 arg2 = static_cast< int >(val2);
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41498 wxPyEndAllowThreads(__tstate);
41499 if (PyErr_Occurred()) SWIG_fail;
41500 }
41501 {
41502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41503 }
41504 return resultobj;
41505 fail:
41506 return NULL;
41507 }
41508
41509
41510 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41511 PyObject *resultobj = 0;
41512 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41513 int arg2 ;
41514 wxString *arg3 = 0 ;
41515 void *argp1 = 0 ;
41516 int res1 = 0 ;
41517 int val2 ;
41518 int ecode2 = 0 ;
41519 bool temp3 = false ;
41520 PyObject * obj0 = 0 ;
41521 PyObject * obj1 = 0 ;
41522 PyObject * obj2 = 0 ;
41523 char * kwnames[] = {
41524 (char *) "self",(char *) "id",(char *) "label", NULL
41525 };
41526
41527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41529 if (!SWIG_IsOK(res1)) {
41530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41531 }
41532 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41533 ecode2 = SWIG_AsVal_int(obj1, &val2);
41534 if (!SWIG_IsOK(ecode2)) {
41535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41536 }
41537 arg2 = static_cast< int >(val2);
41538 {
41539 arg3 = wxString_in_helper(obj2);
41540 if (arg3 == NULL) SWIG_fail;
41541 temp3 = true;
41542 }
41543 {
41544 PyThreadState* __tstate = wxPyBeginAllowThreads();
41545 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41546 wxPyEndAllowThreads(__tstate);
41547 if (PyErr_Occurred()) SWIG_fail;
41548 }
41549 resultobj = SWIG_Py_Void();
41550 {
41551 if (temp3)
41552 delete arg3;
41553 }
41554 return resultobj;
41555 fail:
41556 {
41557 if (temp3)
41558 delete arg3;
41559 }
41560 return NULL;
41561 }
41562
41563
41564 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41565 PyObject *resultobj = 0;
41566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41567 int arg2 ;
41568 wxString result;
41569 void *argp1 = 0 ;
41570 int res1 = 0 ;
41571 int val2 ;
41572 int ecode2 = 0 ;
41573 PyObject * obj0 = 0 ;
41574 PyObject * obj1 = 0 ;
41575 char * kwnames[] = {
41576 (char *) "self",(char *) "id", NULL
41577 };
41578
41579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41581 if (!SWIG_IsOK(res1)) {
41582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41583 }
41584 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41585 ecode2 = SWIG_AsVal_int(obj1, &val2);
41586 if (!SWIG_IsOK(ecode2)) {
41587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41588 }
41589 arg2 = static_cast< int >(val2);
41590 {
41591 PyThreadState* __tstate = wxPyBeginAllowThreads();
41592 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41593 wxPyEndAllowThreads(__tstate);
41594 if (PyErr_Occurred()) SWIG_fail;
41595 }
41596 {
41597 #if wxUSE_UNICODE
41598 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41599 #else
41600 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41601 #endif
41602 }
41603 return resultobj;
41604 fail:
41605 return NULL;
41606 }
41607
41608
41609 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41610 PyObject *resultobj = 0;
41611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41612 int arg2 ;
41613 wxString *arg3 = 0 ;
41614 void *argp1 = 0 ;
41615 int res1 = 0 ;
41616 int val2 ;
41617 int ecode2 = 0 ;
41618 bool temp3 = false ;
41619 PyObject * obj0 = 0 ;
41620 PyObject * obj1 = 0 ;
41621 PyObject * obj2 = 0 ;
41622 char * kwnames[] = {
41623 (char *) "self",(char *) "id",(char *) "helpString", NULL
41624 };
41625
41626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41628 if (!SWIG_IsOK(res1)) {
41629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41630 }
41631 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41632 ecode2 = SWIG_AsVal_int(obj1, &val2);
41633 if (!SWIG_IsOK(ecode2)) {
41634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41635 }
41636 arg2 = static_cast< int >(val2);
41637 {
41638 arg3 = wxString_in_helper(obj2);
41639 if (arg3 == NULL) SWIG_fail;
41640 temp3 = true;
41641 }
41642 {
41643 PyThreadState* __tstate = wxPyBeginAllowThreads();
41644 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41645 wxPyEndAllowThreads(__tstate);
41646 if (PyErr_Occurred()) SWIG_fail;
41647 }
41648 resultobj = SWIG_Py_Void();
41649 {
41650 if (temp3)
41651 delete arg3;
41652 }
41653 return resultobj;
41654 fail:
41655 {
41656 if (temp3)
41657 delete arg3;
41658 }
41659 return NULL;
41660 }
41661
41662
41663 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41664 PyObject *resultobj = 0;
41665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41666 int arg2 ;
41667 wxString result;
41668 void *argp1 = 0 ;
41669 int res1 = 0 ;
41670 int val2 ;
41671 int ecode2 = 0 ;
41672 PyObject * obj0 = 0 ;
41673 PyObject * obj1 = 0 ;
41674 char * kwnames[] = {
41675 (char *) "self",(char *) "id", NULL
41676 };
41677
41678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41680 if (!SWIG_IsOK(res1)) {
41681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41682 }
41683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41684 ecode2 = SWIG_AsVal_int(obj1, &val2);
41685 if (!SWIG_IsOK(ecode2)) {
41686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41687 }
41688 arg2 = static_cast< int >(val2);
41689 {
41690 PyThreadState* __tstate = wxPyBeginAllowThreads();
41691 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41692 wxPyEndAllowThreads(__tstate);
41693 if (PyErr_Occurred()) SWIG_fail;
41694 }
41695 {
41696 #if wxUSE_UNICODE
41697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41698 #else
41699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41700 #endif
41701 }
41702 return resultobj;
41703 fail:
41704 return NULL;
41705 }
41706
41707
41708 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41709 PyObject *resultobj = 0;
41710 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41711 wxFrame *result = 0 ;
41712 void *argp1 = 0 ;
41713 int res1 = 0 ;
41714 PyObject *swig_obj[1] ;
41715
41716 if (!args) SWIG_fail;
41717 swig_obj[0] = args;
41718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41719 if (!SWIG_IsOK(res1)) {
41720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41721 }
41722 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41723 {
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 {
41730 resultobj = wxPyMake_wxObject(result, (bool)0);
41731 }
41732 return resultobj;
41733 fail:
41734 return NULL;
41735 }
41736
41737
41738 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41739 PyObject *resultobj = 0;
41740 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41741 bool result;
41742 void *argp1 = 0 ;
41743 int res1 = 0 ;
41744 PyObject *swig_obj[1] ;
41745
41746 if (!args) SWIG_fail;
41747 swig_obj[0] = args;
41748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41749 if (!SWIG_IsOK(res1)) {
41750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41751 }
41752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41753 {
41754 PyThreadState* __tstate = wxPyBeginAllowThreads();
41755 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41756 wxPyEndAllowThreads(__tstate);
41757 if (PyErr_Occurred()) SWIG_fail;
41758 }
41759 {
41760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41761 }
41762 return resultobj;
41763 fail:
41764 return NULL;
41765 }
41766
41767
41768 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41769 PyObject *resultobj = 0;
41770 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41771 wxFrame *arg2 = (wxFrame *) 0 ;
41772 void *argp1 = 0 ;
41773 int res1 = 0 ;
41774 void *argp2 = 0 ;
41775 int res2 = 0 ;
41776 PyObject * obj0 = 0 ;
41777 PyObject * obj1 = 0 ;
41778 char * kwnames[] = {
41779 (char *) "self",(char *) "frame", NULL
41780 };
41781
41782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41784 if (!SWIG_IsOK(res1)) {
41785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41786 }
41787 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41789 if (!SWIG_IsOK(res2)) {
41790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41791 }
41792 arg2 = reinterpret_cast< wxFrame * >(argp2);
41793 {
41794 PyThreadState* __tstate = wxPyBeginAllowThreads();
41795 (arg1)->Attach(arg2);
41796 wxPyEndAllowThreads(__tstate);
41797 if (PyErr_Occurred()) SWIG_fail;
41798 }
41799 resultobj = SWIG_Py_Void();
41800 return resultobj;
41801 fail:
41802 return NULL;
41803 }
41804
41805
41806 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41807 PyObject *resultobj = 0;
41808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41809 void *argp1 = 0 ;
41810 int res1 = 0 ;
41811 PyObject *swig_obj[1] ;
41812
41813 if (!args) SWIG_fail;
41814 swig_obj[0] = args;
41815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41816 if (!SWIG_IsOK(res1)) {
41817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41818 }
41819 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 (arg1)->Detach();
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 resultobj = SWIG_Py_Void();
41827 return resultobj;
41828 fail:
41829 return NULL;
41830 }
41831
41832
41833 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41834 PyObject *resultobj = 0;
41835 bool arg1 ;
41836 bool val1 ;
41837 int ecode1 = 0 ;
41838 PyObject * obj0 = 0 ;
41839 char * kwnames[] = {
41840 (char *) "enable", NULL
41841 };
41842
41843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41844 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41845 if (!SWIG_IsOK(ecode1)) {
41846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41847 }
41848 arg1 = static_cast< bool >(val1);
41849 {
41850 PyThreadState* __tstate = wxPyBeginAllowThreads();
41851 wxMenuBar_SetAutoWindowMenu(arg1);
41852 wxPyEndAllowThreads(__tstate);
41853 if (PyErr_Occurred()) SWIG_fail;
41854 }
41855 resultobj = SWIG_Py_Void();
41856 return resultobj;
41857 fail:
41858 return NULL;
41859 }
41860
41861
41862 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41863 PyObject *resultobj = 0;
41864 bool result;
41865
41866 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 result = (bool)wxMenuBar_GetAutoWindowMenu();
41870 wxPyEndAllowThreads(__tstate);
41871 if (PyErr_Occurred()) SWIG_fail;
41872 }
41873 {
41874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41875 }
41876 return resultobj;
41877 fail:
41878 return NULL;
41879 }
41880
41881
41882 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41883 PyObject *obj;
41884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41885 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41886 return SWIG_Py_Void();
41887 }
41888
41889 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41890 return SWIG_Python_InitShadowInstance(args);
41891 }
41892
41893 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj = 0;
41895 wxMenu *arg1 = (wxMenu *) NULL ;
41896 int arg2 = (int) wxID_ANY ;
41897 wxString const &arg3_defvalue = wxPyEmptyString ;
41898 wxString *arg3 = (wxString *) &arg3_defvalue ;
41899 wxString const &arg4_defvalue = wxPyEmptyString ;
41900 wxString *arg4 = (wxString *) &arg4_defvalue ;
41901 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41902 wxMenu *arg6 = (wxMenu *) NULL ;
41903 wxMenuItem *result = 0 ;
41904 void *argp1 = 0 ;
41905 int res1 = 0 ;
41906 int val2 ;
41907 int ecode2 = 0 ;
41908 bool temp3 = false ;
41909 bool temp4 = false ;
41910 int val5 ;
41911 int ecode5 = 0 ;
41912 void *argp6 = 0 ;
41913 int res6 = 0 ;
41914 PyObject * obj0 = 0 ;
41915 PyObject * obj1 = 0 ;
41916 PyObject * obj2 = 0 ;
41917 PyObject * obj3 = 0 ;
41918 PyObject * obj4 = 0 ;
41919 PyObject * obj5 = 0 ;
41920 char * kwnames[] = {
41921 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41922 };
41923
41924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41925 if (obj0) {
41926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41927 if (!SWIG_IsOK(res1)) {
41928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41929 }
41930 arg1 = reinterpret_cast< wxMenu * >(argp1);
41931 }
41932 if (obj1) {
41933 ecode2 = SWIG_AsVal_int(obj1, &val2);
41934 if (!SWIG_IsOK(ecode2)) {
41935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41936 }
41937 arg2 = static_cast< int >(val2);
41938 }
41939 if (obj2) {
41940 {
41941 arg3 = wxString_in_helper(obj2);
41942 if (arg3 == NULL) SWIG_fail;
41943 temp3 = true;
41944 }
41945 }
41946 if (obj3) {
41947 {
41948 arg4 = wxString_in_helper(obj3);
41949 if (arg4 == NULL) SWIG_fail;
41950 temp4 = true;
41951 }
41952 }
41953 if (obj4) {
41954 ecode5 = SWIG_AsVal_int(obj4, &val5);
41955 if (!SWIG_IsOK(ecode5)) {
41956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41957 }
41958 arg5 = static_cast< wxItemKind >(val5);
41959 }
41960 if (obj5) {
41961 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41962 if (!SWIG_IsOK(res6)) {
41963 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41964 }
41965 arg6 = reinterpret_cast< wxMenu * >(argp6);
41966 }
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41975 }
41976 {
41977 if (temp3)
41978 delete arg3;
41979 }
41980 {
41981 if (temp4)
41982 delete arg4;
41983 }
41984 return resultobj;
41985 fail:
41986 {
41987 if (temp3)
41988 delete arg3;
41989 }
41990 {
41991 if (temp4)
41992 delete arg4;
41993 }
41994 return NULL;
41995 }
41996
41997
41998 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41999 PyObject *resultobj = 0;
42000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42001 void *argp1 = 0 ;
42002 int res1 = 0 ;
42003 PyObject *swig_obj[1] ;
42004
42005 if (!args) SWIG_fail;
42006 swig_obj[0] = args;
42007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42008 if (!SWIG_IsOK(res1)) {
42009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42010 }
42011 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 delete arg1;
42015
42016 wxPyEndAllowThreads(__tstate);
42017 if (PyErr_Occurred()) SWIG_fail;
42018 }
42019 resultobj = SWIG_Py_Void();
42020 return resultobj;
42021 fail:
42022 return NULL;
42023 }
42024
42025
42026 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42027 PyObject *resultobj = 0;
42028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42029 wxMenu *result = 0 ;
42030 void *argp1 = 0 ;
42031 int res1 = 0 ;
42032 PyObject *swig_obj[1] ;
42033
42034 if (!args) SWIG_fail;
42035 swig_obj[0] = args;
42036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42037 if (!SWIG_IsOK(res1)) {
42038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42039 }
42040 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42041 {
42042 PyThreadState* __tstate = wxPyBeginAllowThreads();
42043 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42044 wxPyEndAllowThreads(__tstate);
42045 if (PyErr_Occurred()) SWIG_fail;
42046 }
42047 {
42048 resultobj = wxPyMake_wxObject(result, 0);
42049 }
42050 return resultobj;
42051 fail:
42052 return NULL;
42053 }
42054
42055
42056 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42057 PyObject *resultobj = 0;
42058 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42059 wxMenu *arg2 = (wxMenu *) 0 ;
42060 void *argp1 = 0 ;
42061 int res1 = 0 ;
42062 void *argp2 = 0 ;
42063 int res2 = 0 ;
42064 PyObject * obj0 = 0 ;
42065 PyObject * obj1 = 0 ;
42066 char * kwnames[] = {
42067 (char *) "self",(char *) "menu", NULL
42068 };
42069
42070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42072 if (!SWIG_IsOK(res1)) {
42073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42074 }
42075 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42076 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42077 if (!SWIG_IsOK(res2)) {
42078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42079 }
42080 arg2 = reinterpret_cast< wxMenu * >(argp2);
42081 {
42082 PyThreadState* __tstate = wxPyBeginAllowThreads();
42083 (arg1)->SetMenu(arg2);
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 resultobj = SWIG_Py_Void();
42088 return resultobj;
42089 fail:
42090 return NULL;
42091 }
42092
42093
42094 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42095 PyObject *resultobj = 0;
42096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42097 int arg2 ;
42098 void *argp1 = 0 ;
42099 int res1 = 0 ;
42100 int val2 ;
42101 int ecode2 = 0 ;
42102 PyObject * obj0 = 0 ;
42103 PyObject * obj1 = 0 ;
42104 char * kwnames[] = {
42105 (char *) "self",(char *) "id", NULL
42106 };
42107
42108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42110 if (!SWIG_IsOK(res1)) {
42111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42112 }
42113 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42114 ecode2 = SWIG_AsVal_int(obj1, &val2);
42115 if (!SWIG_IsOK(ecode2)) {
42116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42117 }
42118 arg2 = static_cast< int >(val2);
42119 {
42120 PyThreadState* __tstate = wxPyBeginAllowThreads();
42121 (arg1)->SetId(arg2);
42122 wxPyEndAllowThreads(__tstate);
42123 if (PyErr_Occurred()) SWIG_fail;
42124 }
42125 resultobj = SWIG_Py_Void();
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42133 PyObject *resultobj = 0;
42134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42135 int result;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 PyObject *swig_obj[1] ;
42139
42140 if (!args) SWIG_fail;
42141 swig_obj[0] = args;
42142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42143 if (!SWIG_IsOK(res1)) {
42144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42145 }
42146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42147 {
42148 PyThreadState* __tstate = wxPyBeginAllowThreads();
42149 result = (int)((wxMenuItem const *)arg1)->GetId();
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 resultobj = SWIG_From_int(static_cast< int >(result));
42154 return resultobj;
42155 fail:
42156 return NULL;
42157 }
42158
42159
42160 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42161 PyObject *resultobj = 0;
42162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42163 bool result;
42164 void *argp1 = 0 ;
42165 int res1 = 0 ;
42166 PyObject *swig_obj[1] ;
42167
42168 if (!args) SWIG_fail;
42169 swig_obj[0] = args;
42170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42171 if (!SWIG_IsOK(res1)) {
42172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42173 }
42174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42193 wxString *arg2 = 0 ;
42194 void *argp1 = 0 ;
42195 int res1 = 0 ;
42196 bool temp2 = false ;
42197 PyObject * obj0 = 0 ;
42198 PyObject * obj1 = 0 ;
42199 char * kwnames[] = {
42200 (char *) "self",(char *) "str", NULL
42201 };
42202
42203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42205 if (!SWIG_IsOK(res1)) {
42206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42207 }
42208 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42209 {
42210 arg2 = wxString_in_helper(obj1);
42211 if (arg2 == NULL) SWIG_fail;
42212 temp2 = true;
42213 }
42214 {
42215 PyThreadState* __tstate = wxPyBeginAllowThreads();
42216 (arg1)->SetText((wxString const &)*arg2);
42217 wxPyEndAllowThreads(__tstate);
42218 if (PyErr_Occurred()) SWIG_fail;
42219 }
42220 resultobj = SWIG_Py_Void();
42221 {
42222 if (temp2)
42223 delete arg2;
42224 }
42225 return resultobj;
42226 fail:
42227 {
42228 if (temp2)
42229 delete arg2;
42230 }
42231 return NULL;
42232 }
42233
42234
42235 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42236 PyObject *resultobj = 0;
42237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42238 wxString result;
42239 void *argp1 = 0 ;
42240 int res1 = 0 ;
42241 PyObject *swig_obj[1] ;
42242
42243 if (!args) SWIG_fail;
42244 swig_obj[0] = args;
42245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42246 if (!SWIG_IsOK(res1)) {
42247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42248 }
42249 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = ((wxMenuItem const *)arg1)->GetLabel();
42253 wxPyEndAllowThreads(__tstate);
42254 if (PyErr_Occurred()) SWIG_fail;
42255 }
42256 {
42257 #if wxUSE_UNICODE
42258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42259 #else
42260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42261 #endif
42262 }
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42270 PyObject *resultobj = 0;
42271 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42272 wxString *result = 0 ;
42273 void *argp1 = 0 ;
42274 int res1 = 0 ;
42275 PyObject *swig_obj[1] ;
42276
42277 if (!args) SWIG_fail;
42278 swig_obj[0] = args;
42279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42282 }
42283 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 {
42287 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42288 result = (wxString *) &_result_ref;
42289 }
42290 wxPyEndAllowThreads(__tstate);
42291 if (PyErr_Occurred()) SWIG_fail;
42292 }
42293 {
42294 #if wxUSE_UNICODE
42295 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42296 #else
42297 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42298 #endif
42299 }
42300 return resultobj;
42301 fail:
42302 return NULL;
42303 }
42304
42305
42306 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42307 PyObject *resultobj = 0;
42308 wxString *arg1 = 0 ;
42309 wxString result;
42310 bool temp1 = false ;
42311 PyObject * obj0 = 0 ;
42312 char * kwnames[] = {
42313 (char *) "text", NULL
42314 };
42315
42316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42317 {
42318 arg1 = wxString_in_helper(obj0);
42319 if (arg1 == NULL) SWIG_fail;
42320 temp1 = true;
42321 }
42322 {
42323 PyThreadState* __tstate = wxPyBeginAllowThreads();
42324 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42325 wxPyEndAllowThreads(__tstate);
42326 if (PyErr_Occurred()) SWIG_fail;
42327 }
42328 {
42329 #if wxUSE_UNICODE
42330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42331 #else
42332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42333 #endif
42334 }
42335 {
42336 if (temp1)
42337 delete arg1;
42338 }
42339 return resultobj;
42340 fail:
42341 {
42342 if (temp1)
42343 delete arg1;
42344 }
42345 return NULL;
42346 }
42347
42348
42349 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42350 PyObject *resultobj = 0;
42351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42352 wxItemKind result;
42353 void *argp1 = 0 ;
42354 int res1 = 0 ;
42355 PyObject *swig_obj[1] ;
42356
42357 if (!args) SWIG_fail;
42358 swig_obj[0] = args;
42359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42360 if (!SWIG_IsOK(res1)) {
42361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42362 }
42363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42364 {
42365 PyThreadState* __tstate = wxPyBeginAllowThreads();
42366 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42367 wxPyEndAllowThreads(__tstate);
42368 if (PyErr_Occurred()) SWIG_fail;
42369 }
42370 resultobj = SWIG_From_int(static_cast< int >(result));
42371 return resultobj;
42372 fail:
42373 return NULL;
42374 }
42375
42376
42377 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42378 PyObject *resultobj = 0;
42379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42380 wxItemKind arg2 ;
42381 void *argp1 = 0 ;
42382 int res1 = 0 ;
42383 int val2 ;
42384 int ecode2 = 0 ;
42385 PyObject * obj0 = 0 ;
42386 PyObject * obj1 = 0 ;
42387 char * kwnames[] = {
42388 (char *) "self",(char *) "kind", NULL
42389 };
42390
42391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42393 if (!SWIG_IsOK(res1)) {
42394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42395 }
42396 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42397 ecode2 = SWIG_AsVal_int(obj1, &val2);
42398 if (!SWIG_IsOK(ecode2)) {
42399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42400 }
42401 arg2 = static_cast< wxItemKind >(val2);
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 (arg1)->SetKind(arg2);
42405 wxPyEndAllowThreads(__tstate);
42406 if (PyErr_Occurred()) SWIG_fail;
42407 }
42408 resultobj = SWIG_Py_Void();
42409 return resultobj;
42410 fail:
42411 return NULL;
42412 }
42413
42414
42415 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42416 PyObject *resultobj = 0;
42417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42418 bool arg2 ;
42419 void *argp1 = 0 ;
42420 int res1 = 0 ;
42421 bool val2 ;
42422 int ecode2 = 0 ;
42423 PyObject * obj0 = 0 ;
42424 PyObject * obj1 = 0 ;
42425 char * kwnames[] = {
42426 (char *) "self",(char *) "checkable", NULL
42427 };
42428
42429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42431 if (!SWIG_IsOK(res1)) {
42432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42433 }
42434 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42436 if (!SWIG_IsOK(ecode2)) {
42437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42438 }
42439 arg2 = static_cast< bool >(val2);
42440 {
42441 PyThreadState* __tstate = wxPyBeginAllowThreads();
42442 (arg1)->SetCheckable(arg2);
42443 wxPyEndAllowThreads(__tstate);
42444 if (PyErr_Occurred()) SWIG_fail;
42445 }
42446 resultobj = SWIG_Py_Void();
42447 return resultobj;
42448 fail:
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42454 PyObject *resultobj = 0;
42455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42456 bool result;
42457 void *argp1 = 0 ;
42458 int res1 = 0 ;
42459 PyObject *swig_obj[1] ;
42460
42461 if (!args) SWIG_fail;
42462 swig_obj[0] = args;
42463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42464 if (!SWIG_IsOK(res1)) {
42465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42466 }
42467 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 {
42475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42476 }
42477 return resultobj;
42478 fail:
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42484 PyObject *resultobj = 0;
42485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42486 bool result;
42487 void *argp1 = 0 ;
42488 int res1 = 0 ;
42489 PyObject *swig_obj[1] ;
42490
42491 if (!args) SWIG_fail;
42492 swig_obj[0] = args;
42493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42494 if (!SWIG_IsOK(res1)) {
42495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42496 }
42497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42498 {
42499 PyThreadState* __tstate = wxPyBeginAllowThreads();
42500 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42501 wxPyEndAllowThreads(__tstate);
42502 if (PyErr_Occurred()) SWIG_fail;
42503 }
42504 {
42505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42506 }
42507 return resultobj;
42508 fail:
42509 return NULL;
42510 }
42511
42512
42513 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42514 PyObject *resultobj = 0;
42515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42516 wxMenu *arg2 = (wxMenu *) 0 ;
42517 void *argp1 = 0 ;
42518 int res1 = 0 ;
42519 void *argp2 = 0 ;
42520 int res2 = 0 ;
42521 PyObject * obj0 = 0 ;
42522 PyObject * obj1 = 0 ;
42523 char * kwnames[] = {
42524 (char *) "self",(char *) "menu", NULL
42525 };
42526
42527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42529 if (!SWIG_IsOK(res1)) {
42530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42531 }
42532 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42534 if (!SWIG_IsOK(res2)) {
42535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42536 }
42537 arg2 = reinterpret_cast< wxMenu * >(argp2);
42538 {
42539 PyThreadState* __tstate = wxPyBeginAllowThreads();
42540 (arg1)->SetSubMenu(arg2);
42541 wxPyEndAllowThreads(__tstate);
42542 if (PyErr_Occurred()) SWIG_fail;
42543 }
42544 resultobj = SWIG_Py_Void();
42545 return resultobj;
42546 fail:
42547 return NULL;
42548 }
42549
42550
42551 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42552 PyObject *resultobj = 0;
42553 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42554 wxMenu *result = 0 ;
42555 void *argp1 = 0 ;
42556 int res1 = 0 ;
42557 PyObject *swig_obj[1] ;
42558
42559 if (!args) SWIG_fail;
42560 swig_obj[0] = args;
42561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42562 if (!SWIG_IsOK(res1)) {
42563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42564 }
42565 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42566 {
42567 PyThreadState* __tstate = wxPyBeginAllowThreads();
42568 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42569 wxPyEndAllowThreads(__tstate);
42570 if (PyErr_Occurred()) SWIG_fail;
42571 }
42572 {
42573 resultobj = wxPyMake_wxObject(result, 0);
42574 }
42575 return resultobj;
42576 fail:
42577 return NULL;
42578 }
42579
42580
42581 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj = 0;
42583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42584 bool arg2 = (bool) true ;
42585 void *argp1 = 0 ;
42586 int res1 = 0 ;
42587 bool val2 ;
42588 int ecode2 = 0 ;
42589 PyObject * obj0 = 0 ;
42590 PyObject * obj1 = 0 ;
42591 char * kwnames[] = {
42592 (char *) "self",(char *) "enable", NULL
42593 };
42594
42595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42597 if (!SWIG_IsOK(res1)) {
42598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42599 }
42600 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42601 if (obj1) {
42602 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42603 if (!SWIG_IsOK(ecode2)) {
42604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42605 }
42606 arg2 = static_cast< bool >(val2);
42607 }
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 (arg1)->Enable(arg2);
42611 wxPyEndAllowThreads(__tstate);
42612 if (PyErr_Occurred()) SWIG_fail;
42613 }
42614 resultobj = SWIG_Py_Void();
42615 return resultobj;
42616 fail:
42617 return NULL;
42618 }
42619
42620
42621 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42622 PyObject *resultobj = 0;
42623 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42624 bool result;
42625 void *argp1 = 0 ;
42626 int res1 = 0 ;
42627 PyObject *swig_obj[1] ;
42628
42629 if (!args) SWIG_fail;
42630 swig_obj[0] = args;
42631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42632 if (!SWIG_IsOK(res1)) {
42633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42634 }
42635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42636 {
42637 PyThreadState* __tstate = wxPyBeginAllowThreads();
42638 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42639 wxPyEndAllowThreads(__tstate);
42640 if (PyErr_Occurred()) SWIG_fail;
42641 }
42642 {
42643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42644 }
42645 return resultobj;
42646 fail:
42647 return NULL;
42648 }
42649
42650
42651 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42652 PyObject *resultobj = 0;
42653 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42654 bool arg2 = (bool) true ;
42655 void *argp1 = 0 ;
42656 int res1 = 0 ;
42657 bool val2 ;
42658 int ecode2 = 0 ;
42659 PyObject * obj0 = 0 ;
42660 PyObject * obj1 = 0 ;
42661 char * kwnames[] = {
42662 (char *) "self",(char *) "check", NULL
42663 };
42664
42665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42667 if (!SWIG_IsOK(res1)) {
42668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42669 }
42670 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42671 if (obj1) {
42672 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42673 if (!SWIG_IsOK(ecode2)) {
42674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42675 }
42676 arg2 = static_cast< bool >(val2);
42677 }
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 (arg1)->Check(arg2);
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 resultobj = SWIG_Py_Void();
42685 return resultobj;
42686 fail:
42687 return NULL;
42688 }
42689
42690
42691 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42692 PyObject *resultobj = 0;
42693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42694 bool result;
42695 void *argp1 = 0 ;
42696 int res1 = 0 ;
42697 PyObject *swig_obj[1] ;
42698
42699 if (!args) SWIG_fail;
42700 swig_obj[0] = args;
42701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42702 if (!SWIG_IsOK(res1)) {
42703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42704 }
42705 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 {
42713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42714 }
42715 return resultobj;
42716 fail:
42717 return NULL;
42718 }
42719
42720
42721 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42722 PyObject *resultobj = 0;
42723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42724 void *argp1 = 0 ;
42725 int res1 = 0 ;
42726 PyObject *swig_obj[1] ;
42727
42728 if (!args) SWIG_fail;
42729 swig_obj[0] = args;
42730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42731 if (!SWIG_IsOK(res1)) {
42732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42733 }
42734 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42735 {
42736 PyThreadState* __tstate = wxPyBeginAllowThreads();
42737 (arg1)->Toggle();
42738 wxPyEndAllowThreads(__tstate);
42739 if (PyErr_Occurred()) SWIG_fail;
42740 }
42741 resultobj = SWIG_Py_Void();
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42749 PyObject *resultobj = 0;
42750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42751 wxString *arg2 = 0 ;
42752 void *argp1 = 0 ;
42753 int res1 = 0 ;
42754 bool temp2 = false ;
42755 PyObject * obj0 = 0 ;
42756 PyObject * obj1 = 0 ;
42757 char * kwnames[] = {
42758 (char *) "self",(char *) "str", NULL
42759 };
42760
42761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42763 if (!SWIG_IsOK(res1)) {
42764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42765 }
42766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42767 {
42768 arg2 = wxString_in_helper(obj1);
42769 if (arg2 == NULL) SWIG_fail;
42770 temp2 = true;
42771 }
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 (arg1)->SetHelp((wxString const &)*arg2);
42775 wxPyEndAllowThreads(__tstate);
42776 if (PyErr_Occurred()) SWIG_fail;
42777 }
42778 resultobj = SWIG_Py_Void();
42779 {
42780 if (temp2)
42781 delete arg2;
42782 }
42783 return resultobj;
42784 fail:
42785 {
42786 if (temp2)
42787 delete arg2;
42788 }
42789 return NULL;
42790 }
42791
42792
42793 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42794 PyObject *resultobj = 0;
42795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42796 wxString *result = 0 ;
42797 void *argp1 = 0 ;
42798 int res1 = 0 ;
42799 PyObject *swig_obj[1] ;
42800
42801 if (!args) SWIG_fail;
42802 swig_obj[0] = args;
42803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 {
42811 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42812 result = (wxString *) &_result_ref;
42813 }
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 {
42818 #if wxUSE_UNICODE
42819 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42820 #else
42821 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42822 #endif
42823 }
42824 return resultobj;
42825 fail:
42826 return NULL;
42827 }
42828
42829
42830 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42831 PyObject *resultobj = 0;
42832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42833 wxAcceleratorEntry *result = 0 ;
42834 void *argp1 = 0 ;
42835 int res1 = 0 ;
42836 PyObject *swig_obj[1] ;
42837
42838 if (!args) SWIG_fail;
42839 swig_obj[0] = args;
42840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42841 if (!SWIG_IsOK(res1)) {
42842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42843 }
42844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42845 {
42846 PyThreadState* __tstate = wxPyBeginAllowThreads();
42847 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42852 return resultobj;
42853 fail:
42854 return NULL;
42855 }
42856
42857
42858 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42859 PyObject *resultobj = 0;
42860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42861 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42862 void *argp1 = 0 ;
42863 int res1 = 0 ;
42864 void *argp2 = 0 ;
42865 int res2 = 0 ;
42866 PyObject * obj0 = 0 ;
42867 PyObject * obj1 = 0 ;
42868 char * kwnames[] = {
42869 (char *) "self",(char *) "accel", NULL
42870 };
42871
42872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42874 if (!SWIG_IsOK(res1)) {
42875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42876 }
42877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42879 if (!SWIG_IsOK(res2)) {
42880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42881 }
42882 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->SetAccel(arg2);
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_Py_Void();
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42897 PyObject *resultobj = 0;
42898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42899 wxBitmap *arg2 = 0 ;
42900 void *argp1 = 0 ;
42901 int res1 = 0 ;
42902 void *argp2 = 0 ;
42903 int res2 = 0 ;
42904 PyObject * obj0 = 0 ;
42905 PyObject * obj1 = 0 ;
42906 char * kwnames[] = {
42907 (char *) "self",(char *) "bitmap", NULL
42908 };
42909
42910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42912 if (!SWIG_IsOK(res1)) {
42913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42914 }
42915 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42917 if (!SWIG_IsOK(res2)) {
42918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42919 }
42920 if (!argp2) {
42921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42922 }
42923 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42924 {
42925 PyThreadState* __tstate = wxPyBeginAllowThreads();
42926 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42927 wxPyEndAllowThreads(__tstate);
42928 if (PyErr_Occurred()) SWIG_fail;
42929 }
42930 resultobj = SWIG_Py_Void();
42931 return resultobj;
42932 fail:
42933 return NULL;
42934 }
42935
42936
42937 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42938 PyObject *resultobj = 0;
42939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42940 wxBitmap *result = 0 ;
42941 void *argp1 = 0 ;
42942 int res1 = 0 ;
42943 PyObject *swig_obj[1] ;
42944
42945 if (!args) SWIG_fail;
42946 swig_obj[0] = args;
42947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42948 if (!SWIG_IsOK(res1)) {
42949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42950 }
42951 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42952 {
42953 PyThreadState* __tstate = wxPyBeginAllowThreads();
42954 {
42955 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42956 result = (wxBitmap *) &_result_ref;
42957 }
42958 wxPyEndAllowThreads(__tstate);
42959 if (PyErr_Occurred()) SWIG_fail;
42960 }
42961 {
42962 wxBitmap* resultptr = new wxBitmap(*result);
42963 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42964 }
42965 return resultobj;
42966 fail:
42967 return NULL;
42968 }
42969
42970
42971 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42972 PyObject *resultobj = 0;
42973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42974 wxFont *arg2 = 0 ;
42975 void *argp1 = 0 ;
42976 int res1 = 0 ;
42977 void *argp2 = 0 ;
42978 int res2 = 0 ;
42979 PyObject * obj0 = 0 ;
42980 PyObject * obj1 = 0 ;
42981 char * kwnames[] = {
42982 (char *) "self",(char *) "font", NULL
42983 };
42984
42985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42987 if (!SWIG_IsOK(res1)) {
42988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42989 }
42990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42992 if (!SWIG_IsOK(res2)) {
42993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42994 }
42995 if (!argp2) {
42996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42997 }
42998 arg2 = reinterpret_cast< wxFont * >(argp2);
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 (arg1)->SetFont((wxFont const &)*arg2);
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 resultobj = SWIG_Py_Void();
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43013 PyObject *resultobj = 0;
43014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43015 wxFont result;
43016 void *argp1 = 0 ;
43017 int res1 = 0 ;
43018 PyObject *swig_obj[1] ;
43019
43020 if (!args) SWIG_fail;
43021 swig_obj[0] = args;
43022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43023 if (!SWIG_IsOK(res1)) {
43024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43025 }
43026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (arg1)->GetFont();
43030 wxPyEndAllowThreads(__tstate);
43031 if (PyErr_Occurred()) SWIG_fail;
43032 }
43033 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43034 return resultobj;
43035 fail:
43036 return NULL;
43037 }
43038
43039
43040 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43041 PyObject *resultobj = 0;
43042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43043 wxColour *arg2 = 0 ;
43044 void *argp1 = 0 ;
43045 int res1 = 0 ;
43046 wxColour temp2 ;
43047 PyObject * obj0 = 0 ;
43048 PyObject * obj1 = 0 ;
43049 char * kwnames[] = {
43050 (char *) "self",(char *) "colText", NULL
43051 };
43052
43053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43055 if (!SWIG_IsOK(res1)) {
43056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43057 }
43058 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43059 {
43060 arg2 = &temp2;
43061 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43062 }
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 (arg1)->SetTextColour((wxColour const &)*arg2);
43066 wxPyEndAllowThreads(__tstate);
43067 if (PyErr_Occurred()) SWIG_fail;
43068 }
43069 resultobj = SWIG_Py_Void();
43070 return resultobj;
43071 fail:
43072 return NULL;
43073 }
43074
43075
43076 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43077 PyObject *resultobj = 0;
43078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43079 wxColour result;
43080 void *argp1 = 0 ;
43081 int res1 = 0 ;
43082 PyObject *swig_obj[1] ;
43083
43084 if (!args) SWIG_fail;
43085 swig_obj[0] = args;
43086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43087 if (!SWIG_IsOK(res1)) {
43088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43089 }
43090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43091 {
43092 PyThreadState* __tstate = wxPyBeginAllowThreads();
43093 result = (arg1)->GetTextColour();
43094 wxPyEndAllowThreads(__tstate);
43095 if (PyErr_Occurred()) SWIG_fail;
43096 }
43097 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43098 return resultobj;
43099 fail:
43100 return NULL;
43101 }
43102
43103
43104 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43105 PyObject *resultobj = 0;
43106 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43107 wxColour *arg2 = 0 ;
43108 void *argp1 = 0 ;
43109 int res1 = 0 ;
43110 wxColour temp2 ;
43111 PyObject * obj0 = 0 ;
43112 PyObject * obj1 = 0 ;
43113 char * kwnames[] = {
43114 (char *) "self",(char *) "colBack", NULL
43115 };
43116
43117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43119 if (!SWIG_IsOK(res1)) {
43120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43121 }
43122 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43123 {
43124 arg2 = &temp2;
43125 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43126 }
43127 {
43128 PyThreadState* __tstate = wxPyBeginAllowThreads();
43129 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43130 wxPyEndAllowThreads(__tstate);
43131 if (PyErr_Occurred()) SWIG_fail;
43132 }
43133 resultobj = SWIG_Py_Void();
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43141 PyObject *resultobj = 0;
43142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43143 wxColour result;
43144 void *argp1 = 0 ;
43145 int res1 = 0 ;
43146 PyObject *swig_obj[1] ;
43147
43148 if (!args) SWIG_fail;
43149 swig_obj[0] = args;
43150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43151 if (!SWIG_IsOK(res1)) {
43152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43153 }
43154 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43155 {
43156 PyThreadState* __tstate = wxPyBeginAllowThreads();
43157 result = (arg1)->GetBackgroundColour();
43158 wxPyEndAllowThreads(__tstate);
43159 if (PyErr_Occurred()) SWIG_fail;
43160 }
43161 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43162 return resultobj;
43163 fail:
43164 return NULL;
43165 }
43166
43167
43168 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43169 PyObject *resultobj = 0;
43170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43171 wxBitmap *arg2 = 0 ;
43172 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43173 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43174 void *argp1 = 0 ;
43175 int res1 = 0 ;
43176 void *argp2 = 0 ;
43177 int res2 = 0 ;
43178 void *argp3 = 0 ;
43179 int res3 = 0 ;
43180 PyObject * obj0 = 0 ;
43181 PyObject * obj1 = 0 ;
43182 PyObject * obj2 = 0 ;
43183 char * kwnames[] = {
43184 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43185 };
43186
43187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43189 if (!SWIG_IsOK(res1)) {
43190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43191 }
43192 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43194 if (!SWIG_IsOK(res2)) {
43195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43196 }
43197 if (!argp2) {
43198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43199 }
43200 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43201 if (obj2) {
43202 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43203 if (!SWIG_IsOK(res3)) {
43204 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43205 }
43206 if (!argp3) {
43207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43208 }
43209 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43210 }
43211 {
43212 PyThreadState* __tstate = wxPyBeginAllowThreads();
43213 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 resultobj = SWIG_Py_Void();
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43225 PyObject *resultobj = 0;
43226 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43227 wxBitmap *arg2 = 0 ;
43228 void *argp1 = 0 ;
43229 int res1 = 0 ;
43230 void *argp2 = 0 ;
43231 int res2 = 0 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 char * kwnames[] = {
43235 (char *) "self",(char *) "bmpDisabled", NULL
43236 };
43237
43238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43240 if (!SWIG_IsOK(res1)) {
43241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43242 }
43243 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43245 if (!SWIG_IsOK(res2)) {
43246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43247 }
43248 if (!argp2) {
43249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43250 }
43251 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 resultobj = SWIG_Py_Void();
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43266 PyObject *resultobj = 0;
43267 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43268 wxBitmap *result = 0 ;
43269 void *argp1 = 0 ;
43270 int res1 = 0 ;
43271 PyObject *swig_obj[1] ;
43272
43273 if (!args) SWIG_fail;
43274 swig_obj[0] = args;
43275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 {
43283 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43284 result = (wxBitmap *) &_result_ref;
43285 }
43286 wxPyEndAllowThreads(__tstate);
43287 if (PyErr_Occurred()) SWIG_fail;
43288 }
43289 {
43290 wxBitmap* resultptr = new wxBitmap(*result);
43291 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43292 }
43293 return resultobj;
43294 fail:
43295 return NULL;
43296 }
43297
43298
43299 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43300 PyObject *resultobj = 0;
43301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43302 int arg2 ;
43303 void *argp1 = 0 ;
43304 int res1 = 0 ;
43305 int val2 ;
43306 int ecode2 = 0 ;
43307 PyObject * obj0 = 0 ;
43308 PyObject * obj1 = 0 ;
43309 char * kwnames[] = {
43310 (char *) "self",(char *) "nWidth", NULL
43311 };
43312
43313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43315 if (!SWIG_IsOK(res1)) {
43316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43317 }
43318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43319 ecode2 = SWIG_AsVal_int(obj1, &val2);
43320 if (!SWIG_IsOK(ecode2)) {
43321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43322 }
43323 arg2 = static_cast< int >(val2);
43324 {
43325 PyThreadState* __tstate = wxPyBeginAllowThreads();
43326 (arg1)->SetMarginWidth(arg2);
43327 wxPyEndAllowThreads(__tstate);
43328 if (PyErr_Occurred()) SWIG_fail;
43329 }
43330 resultobj = SWIG_Py_Void();
43331 return resultobj;
43332 fail:
43333 return NULL;
43334 }
43335
43336
43337 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43338 PyObject *resultobj = 0;
43339 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43340 int result;
43341 void *argp1 = 0 ;
43342 int res1 = 0 ;
43343 PyObject *swig_obj[1] ;
43344
43345 if (!args) SWIG_fail;
43346 swig_obj[0] = args;
43347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43348 if (!SWIG_IsOK(res1)) {
43349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43350 }
43351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43352 {
43353 PyThreadState* __tstate = wxPyBeginAllowThreads();
43354 result = (int)(arg1)->GetMarginWidth();
43355 wxPyEndAllowThreads(__tstate);
43356 if (PyErr_Occurred()) SWIG_fail;
43357 }
43358 resultobj = SWIG_From_int(static_cast< int >(result));
43359 return resultobj;
43360 fail:
43361 return NULL;
43362 }
43363
43364
43365 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43366 PyObject *resultobj = 0;
43367 int result;
43368
43369 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43370 {
43371 PyThreadState* __tstate = wxPyBeginAllowThreads();
43372 result = (int)wxMenuItem::GetDefaultMarginWidth();
43373 wxPyEndAllowThreads(__tstate);
43374 if (PyErr_Occurred()) SWIG_fail;
43375 }
43376 resultobj = SWIG_From_int(static_cast< int >(result));
43377 return resultobj;
43378 fail:
43379 return NULL;
43380 }
43381
43382
43383 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43384 PyObject *resultobj = 0;
43385 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43386 bool result;
43387 void *argp1 = 0 ;
43388 int res1 = 0 ;
43389 PyObject *swig_obj[1] ;
43390
43391 if (!args) SWIG_fail;
43392 swig_obj[0] = args;
43393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43394 if (!SWIG_IsOK(res1)) {
43395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43396 }
43397 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43398 {
43399 PyThreadState* __tstate = wxPyBeginAllowThreads();
43400 result = (bool)(arg1)->IsOwnerDrawn();
43401 wxPyEndAllowThreads(__tstate);
43402 if (PyErr_Occurred()) SWIG_fail;
43403 }
43404 {
43405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43406 }
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43414 PyObject *resultobj = 0;
43415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43416 bool arg2 = (bool) true ;
43417 void *argp1 = 0 ;
43418 int res1 = 0 ;
43419 bool val2 ;
43420 int ecode2 = 0 ;
43421 PyObject * obj0 = 0 ;
43422 PyObject * obj1 = 0 ;
43423 char * kwnames[] = {
43424 (char *) "self",(char *) "ownerDrawn", NULL
43425 };
43426
43427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43429 if (!SWIG_IsOK(res1)) {
43430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43431 }
43432 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43433 if (obj1) {
43434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43435 if (!SWIG_IsOK(ecode2)) {
43436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43437 }
43438 arg2 = static_cast< bool >(val2);
43439 }
43440 {
43441 PyThreadState* __tstate = wxPyBeginAllowThreads();
43442 (arg1)->SetOwnerDrawn(arg2);
43443 wxPyEndAllowThreads(__tstate);
43444 if (PyErr_Occurred()) SWIG_fail;
43445 }
43446 resultobj = SWIG_Py_Void();
43447 return resultobj;
43448 fail:
43449 return NULL;
43450 }
43451
43452
43453 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43454 PyObject *resultobj = 0;
43455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43456 void *argp1 = 0 ;
43457 int res1 = 0 ;
43458 PyObject *swig_obj[1] ;
43459
43460 if (!args) SWIG_fail;
43461 swig_obj[0] = args;
43462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43463 if (!SWIG_IsOK(res1)) {
43464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43465 }
43466 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43467 {
43468 PyThreadState* __tstate = wxPyBeginAllowThreads();
43469 (arg1)->ResetOwnerDrawn();
43470 wxPyEndAllowThreads(__tstate);
43471 if (PyErr_Occurred()) SWIG_fail;
43472 }
43473 resultobj = SWIG_Py_Void();
43474 return resultobj;
43475 fail:
43476 return NULL;
43477 }
43478
43479
43480 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43481 PyObject *obj;
43482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43483 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43484 return SWIG_Py_Void();
43485 }
43486
43487 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43488 return SWIG_Python_InitShadowInstance(args);
43489 }
43490
43491 SWIGINTERN int ControlNameStr_set(PyObject *) {
43492 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43493 return 1;
43494 }
43495
43496
43497 SWIGINTERN PyObject *ControlNameStr_get(void) {
43498 PyObject *pyobj = 0;
43499
43500 {
43501 #if wxUSE_UNICODE
43502 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43503 #else
43504 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43505 #endif
43506 }
43507 return pyobj;
43508 }
43509
43510
43511 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43512 PyObject *resultobj = 0;
43513 wxWindow *arg1 = (wxWindow *) 0 ;
43514 int arg2 = (int) -1 ;
43515 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43516 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43517 wxSize const &arg4_defvalue = wxDefaultSize ;
43518 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43519 long arg5 = (long) 0 ;
43520 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43521 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43522 wxString const &arg7_defvalue = wxPyControlNameStr ;
43523 wxString *arg7 = (wxString *) &arg7_defvalue ;
43524 wxControl *result = 0 ;
43525 void *argp1 = 0 ;
43526 int res1 = 0 ;
43527 int val2 ;
43528 int ecode2 = 0 ;
43529 wxPoint temp3 ;
43530 wxSize temp4 ;
43531 long val5 ;
43532 int ecode5 = 0 ;
43533 void *argp6 = 0 ;
43534 int res6 = 0 ;
43535 bool temp7 = false ;
43536 PyObject * obj0 = 0 ;
43537 PyObject * obj1 = 0 ;
43538 PyObject * obj2 = 0 ;
43539 PyObject * obj3 = 0 ;
43540 PyObject * obj4 = 0 ;
43541 PyObject * obj5 = 0 ;
43542 PyObject * obj6 = 0 ;
43543 char * kwnames[] = {
43544 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43545 };
43546
43547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43549 if (!SWIG_IsOK(res1)) {
43550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43551 }
43552 arg1 = reinterpret_cast< wxWindow * >(argp1);
43553 if (obj1) {
43554 ecode2 = SWIG_AsVal_int(obj1, &val2);
43555 if (!SWIG_IsOK(ecode2)) {
43556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43557 }
43558 arg2 = static_cast< int >(val2);
43559 }
43560 if (obj2) {
43561 {
43562 arg3 = &temp3;
43563 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43564 }
43565 }
43566 if (obj3) {
43567 {
43568 arg4 = &temp4;
43569 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43570 }
43571 }
43572 if (obj4) {
43573 ecode5 = SWIG_AsVal_long(obj4, &val5);
43574 if (!SWIG_IsOK(ecode5)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43576 }
43577 arg5 = static_cast< long >(val5);
43578 }
43579 if (obj5) {
43580 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43581 if (!SWIG_IsOK(res6)) {
43582 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43583 }
43584 if (!argp6) {
43585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43586 }
43587 arg6 = reinterpret_cast< wxValidator * >(argp6);
43588 }
43589 if (obj6) {
43590 {
43591 arg7 = wxString_in_helper(obj6);
43592 if (arg7 == NULL) SWIG_fail;
43593 temp7 = true;
43594 }
43595 }
43596 {
43597 if (!wxPyCheckForApp()) SWIG_fail;
43598 PyThreadState* __tstate = wxPyBeginAllowThreads();
43599 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43600 wxPyEndAllowThreads(__tstate);
43601 if (PyErr_Occurred()) SWIG_fail;
43602 }
43603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43604 {
43605 if (temp7)
43606 delete arg7;
43607 }
43608 return resultobj;
43609 fail:
43610 {
43611 if (temp7)
43612 delete arg7;
43613 }
43614 return NULL;
43615 }
43616
43617
43618 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43619 PyObject *resultobj = 0;
43620 wxControl *result = 0 ;
43621
43622 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43623 {
43624 if (!wxPyCheckForApp()) SWIG_fail;
43625 PyThreadState* __tstate = wxPyBeginAllowThreads();
43626 result = (wxControl *)new wxControl();
43627 wxPyEndAllowThreads(__tstate);
43628 if (PyErr_Occurred()) SWIG_fail;
43629 }
43630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = 0;
43639 wxControl *arg1 = (wxControl *) 0 ;
43640 wxWindow *arg2 = (wxWindow *) 0 ;
43641 int arg3 = (int) -1 ;
43642 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43643 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43644 wxSize const &arg5_defvalue = wxDefaultSize ;
43645 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43646 long arg6 = (long) 0 ;
43647 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43648 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43649 wxString const &arg8_defvalue = wxPyControlNameStr ;
43650 wxString *arg8 = (wxString *) &arg8_defvalue ;
43651 bool result;
43652 void *argp1 = 0 ;
43653 int res1 = 0 ;
43654 void *argp2 = 0 ;
43655 int res2 = 0 ;
43656 int val3 ;
43657 int ecode3 = 0 ;
43658 wxPoint temp4 ;
43659 wxSize temp5 ;
43660 long val6 ;
43661 int ecode6 = 0 ;
43662 void *argp7 = 0 ;
43663 int res7 = 0 ;
43664 bool temp8 = false ;
43665 PyObject * obj0 = 0 ;
43666 PyObject * obj1 = 0 ;
43667 PyObject * obj2 = 0 ;
43668 PyObject * obj3 = 0 ;
43669 PyObject * obj4 = 0 ;
43670 PyObject * obj5 = 0 ;
43671 PyObject * obj6 = 0 ;
43672 PyObject * obj7 = 0 ;
43673 char * kwnames[] = {
43674 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43675 };
43676
43677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43679 if (!SWIG_IsOK(res1)) {
43680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43681 }
43682 arg1 = reinterpret_cast< wxControl * >(argp1);
43683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43684 if (!SWIG_IsOK(res2)) {
43685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43686 }
43687 arg2 = reinterpret_cast< wxWindow * >(argp2);
43688 if (obj2) {
43689 ecode3 = SWIG_AsVal_int(obj2, &val3);
43690 if (!SWIG_IsOK(ecode3)) {
43691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43692 }
43693 arg3 = static_cast< int >(val3);
43694 }
43695 if (obj3) {
43696 {
43697 arg4 = &temp4;
43698 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43699 }
43700 }
43701 if (obj4) {
43702 {
43703 arg5 = &temp5;
43704 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43705 }
43706 }
43707 if (obj5) {
43708 ecode6 = SWIG_AsVal_long(obj5, &val6);
43709 if (!SWIG_IsOK(ecode6)) {
43710 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43711 }
43712 arg6 = static_cast< long >(val6);
43713 }
43714 if (obj6) {
43715 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43716 if (!SWIG_IsOK(res7)) {
43717 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43718 }
43719 if (!argp7) {
43720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43721 }
43722 arg7 = reinterpret_cast< wxValidator * >(argp7);
43723 }
43724 if (obj7) {
43725 {
43726 arg8 = wxString_in_helper(obj7);
43727 if (arg8 == NULL) SWIG_fail;
43728 temp8 = true;
43729 }
43730 }
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 {
43738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43739 }
43740 {
43741 if (temp8)
43742 delete arg8;
43743 }
43744 return resultobj;
43745 fail:
43746 {
43747 if (temp8)
43748 delete arg8;
43749 }
43750 return NULL;
43751 }
43752
43753
43754 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43755 PyObject *resultobj = 0;
43756 wxControl *arg1 = (wxControl *) 0 ;
43757 wxCommandEvent *arg2 = 0 ;
43758 void *argp1 = 0 ;
43759 int res1 = 0 ;
43760 void *argp2 = 0 ;
43761 int res2 = 0 ;
43762 PyObject * obj0 = 0 ;
43763 PyObject * obj1 = 0 ;
43764 char * kwnames[] = {
43765 (char *) "self",(char *) "event", NULL
43766 };
43767
43768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43770 if (!SWIG_IsOK(res1)) {
43771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43772 }
43773 arg1 = reinterpret_cast< wxControl * >(argp1);
43774 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43775 if (!SWIG_IsOK(res2)) {
43776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43777 }
43778 if (!argp2) {
43779 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43780 }
43781 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43782 {
43783 PyThreadState* __tstate = wxPyBeginAllowThreads();
43784 (arg1)->Command(*arg2);
43785 wxPyEndAllowThreads(__tstate);
43786 if (PyErr_Occurred()) SWIG_fail;
43787 }
43788 resultobj = SWIG_Py_Void();
43789 return resultobj;
43790 fail:
43791 return NULL;
43792 }
43793
43794
43795 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43796 PyObject *resultobj = 0;
43797 wxControl *arg1 = (wxControl *) 0 ;
43798 wxString result;
43799 void *argp1 = 0 ;
43800 int res1 = 0 ;
43801 PyObject *swig_obj[1] ;
43802
43803 if (!args) SWIG_fail;
43804 swig_obj[0] = args;
43805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43806 if (!SWIG_IsOK(res1)) {
43807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43808 }
43809 arg1 = reinterpret_cast< wxControl * >(argp1);
43810 {
43811 PyThreadState* __tstate = wxPyBeginAllowThreads();
43812 result = (arg1)->GetLabel();
43813 wxPyEndAllowThreads(__tstate);
43814 if (PyErr_Occurred()) SWIG_fail;
43815 }
43816 {
43817 #if wxUSE_UNICODE
43818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43819 #else
43820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43821 #endif
43822 }
43823 return resultobj;
43824 fail:
43825 return NULL;
43826 }
43827
43828
43829 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43830 PyObject *resultobj = 0;
43831 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43832 SwigValueWrapper<wxVisualAttributes > result;
43833 int val1 ;
43834 int ecode1 = 0 ;
43835 PyObject * obj0 = 0 ;
43836 char * kwnames[] = {
43837 (char *) "variant", NULL
43838 };
43839
43840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43841 if (obj0) {
43842 ecode1 = SWIG_AsVal_int(obj0, &val1);
43843 if (!SWIG_IsOK(ecode1)) {
43844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43845 }
43846 arg1 = static_cast< wxWindowVariant >(val1);
43847 }
43848 {
43849 if (!wxPyCheckForApp()) SWIG_fail;
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 result = wxControl::GetClassDefaultAttributes(arg1);
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43856 return resultobj;
43857 fail:
43858 return NULL;
43859 }
43860
43861
43862 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43863 PyObject *obj;
43864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43865 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43866 return SWIG_Py_Void();
43867 }
43868
43869 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43870 return SWIG_Python_InitShadowInstance(args);
43871 }
43872
43873 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43874 PyObject *resultobj = 0;
43875 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43876 wxString *arg2 = 0 ;
43877 PyObject *arg3 = (PyObject *) NULL ;
43878 int result;
43879 void *argp1 = 0 ;
43880 int res1 = 0 ;
43881 bool temp2 = false ;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884 PyObject * obj2 = 0 ;
43885 char * kwnames[] = {
43886 (char *) "self",(char *) "item",(char *) "clientData", NULL
43887 };
43888
43889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43893 }
43894 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43895 {
43896 arg2 = wxString_in_helper(obj1);
43897 if (arg2 == NULL) SWIG_fail;
43898 temp2 = true;
43899 }
43900 if (obj2) {
43901 arg3 = obj2;
43902 }
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43906 wxPyEndAllowThreads(__tstate);
43907 if (PyErr_Occurred()) SWIG_fail;
43908 }
43909 resultobj = SWIG_From_int(static_cast< int >(result));
43910 {
43911 if (temp2)
43912 delete arg2;
43913 }
43914 return resultobj;
43915 fail:
43916 {
43917 if (temp2)
43918 delete arg2;
43919 }
43920 return NULL;
43921 }
43922
43923
43924 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43925 PyObject *resultobj = 0;
43926 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43927 wxArrayString *arg2 = 0 ;
43928 void *argp1 = 0 ;
43929 int res1 = 0 ;
43930 bool temp2 = false ;
43931 PyObject * obj0 = 0 ;
43932 PyObject * obj1 = 0 ;
43933 char * kwnames[] = {
43934 (char *) "self",(char *) "strings", NULL
43935 };
43936
43937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43939 if (!SWIG_IsOK(res1)) {
43940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43941 }
43942 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43943 {
43944 if (! PySequence_Check(obj1)) {
43945 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43946 SWIG_fail;
43947 }
43948 arg2 = new wxArrayString;
43949 temp2 = true;
43950 int i, len=PySequence_Length(obj1);
43951 for (i=0; i<len; i++) {
43952 PyObject* item = PySequence_GetItem(obj1, i);
43953 wxString* s = wxString_in_helper(item);
43954 if (PyErr_Occurred()) SWIG_fail;
43955 arg2->Add(*s);
43956 delete s;
43957 Py_DECREF(item);
43958 }
43959 }
43960 {
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 (arg1)->Append((wxArrayString const &)*arg2);
43963 wxPyEndAllowThreads(__tstate);
43964 if (PyErr_Occurred()) SWIG_fail;
43965 }
43966 resultobj = SWIG_Py_Void();
43967 {
43968 if (temp2) delete arg2;
43969 }
43970 return resultobj;
43971 fail:
43972 {
43973 if (temp2) delete arg2;
43974 }
43975 return NULL;
43976 }
43977
43978
43979 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43980 PyObject *resultobj = 0;
43981 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43982 wxString *arg2 = 0 ;
43983 unsigned int arg3 ;
43984 PyObject *arg4 = (PyObject *) NULL ;
43985 int result;
43986 void *argp1 = 0 ;
43987 int res1 = 0 ;
43988 bool temp2 = false ;
43989 unsigned int val3 ;
43990 int ecode3 = 0 ;
43991 PyObject * obj0 = 0 ;
43992 PyObject * obj1 = 0 ;
43993 PyObject * obj2 = 0 ;
43994 PyObject * obj3 = 0 ;
43995 char * kwnames[] = {
43996 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43997 };
43998
43999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44001 if (!SWIG_IsOK(res1)) {
44002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44003 }
44004 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44005 {
44006 arg2 = wxString_in_helper(obj1);
44007 if (arg2 == NULL) SWIG_fail;
44008 temp2 = true;
44009 }
44010 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44011 if (!SWIG_IsOK(ecode3)) {
44012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44013 }
44014 arg3 = static_cast< unsigned int >(val3);
44015 if (obj3) {
44016 arg4 = obj3;
44017 }
44018 {
44019 PyThreadState* __tstate = wxPyBeginAllowThreads();
44020 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44021 wxPyEndAllowThreads(__tstate);
44022 if (PyErr_Occurred()) SWIG_fail;
44023 }
44024 resultobj = SWIG_From_int(static_cast< int >(result));
44025 {
44026 if (temp2)
44027 delete arg2;
44028 }
44029 return resultobj;
44030 fail:
44031 {
44032 if (temp2)
44033 delete arg2;
44034 }
44035 return NULL;
44036 }
44037
44038
44039 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44040 PyObject *resultobj = 0;
44041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44042 void *argp1 = 0 ;
44043 int res1 = 0 ;
44044 PyObject *swig_obj[1] ;
44045
44046 if (!args) SWIG_fail;
44047 swig_obj[0] = args;
44048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44049 if (!SWIG_IsOK(res1)) {
44050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44051 }
44052 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44053 {
44054 PyThreadState* __tstate = wxPyBeginAllowThreads();
44055 (arg1)->Clear();
44056 wxPyEndAllowThreads(__tstate);
44057 if (PyErr_Occurred()) SWIG_fail;
44058 }
44059 resultobj = SWIG_Py_Void();
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj = 0;
44068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44069 unsigned int arg2 ;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 unsigned int val2 ;
44073 int ecode2 = 0 ;
44074 PyObject * obj0 = 0 ;
44075 PyObject * obj1 = 0 ;
44076 char * kwnames[] = {
44077 (char *) "self",(char *) "n", NULL
44078 };
44079
44080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44082 if (!SWIG_IsOK(res1)) {
44083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44084 }
44085 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44086 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44087 if (!SWIG_IsOK(ecode2)) {
44088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44089 }
44090 arg2 = static_cast< unsigned int >(val2);
44091 {
44092 PyThreadState* __tstate = wxPyBeginAllowThreads();
44093 (arg1)->Delete(arg2);
44094 wxPyEndAllowThreads(__tstate);
44095 if (PyErr_Occurred()) SWIG_fail;
44096 }
44097 resultobj = SWIG_Py_Void();
44098 return resultobj;
44099 fail:
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44105 PyObject *resultobj = 0;
44106 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44107 unsigned int arg2 ;
44108 PyObject *result = 0 ;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 unsigned int val2 ;
44112 int ecode2 = 0 ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 char * kwnames[] = {
44116 (char *) "self",(char *) "n", NULL
44117 };
44118
44119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44121 if (!SWIG_IsOK(res1)) {
44122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44123 }
44124 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44125 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44126 if (!SWIG_IsOK(ecode2)) {
44127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44128 }
44129 arg2 = static_cast< unsigned int >(val2);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 resultobj = result;
44137 return resultobj;
44138 fail:
44139 return NULL;
44140 }
44141
44142
44143 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44144 PyObject *resultobj = 0;
44145 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44146 unsigned int arg2 ;
44147 PyObject *arg3 = (PyObject *) 0 ;
44148 void *argp1 = 0 ;
44149 int res1 = 0 ;
44150 unsigned int val2 ;
44151 int ecode2 = 0 ;
44152 PyObject * obj0 = 0 ;
44153 PyObject * obj1 = 0 ;
44154 PyObject * obj2 = 0 ;
44155 char * kwnames[] = {
44156 (char *) "self",(char *) "n",(char *) "clientData", NULL
44157 };
44158
44159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44161 if (!SWIG_IsOK(res1)) {
44162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44163 }
44164 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44165 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44166 if (!SWIG_IsOK(ecode2)) {
44167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44168 }
44169 arg2 = static_cast< unsigned int >(val2);
44170 arg3 = obj2;
44171 {
44172 PyThreadState* __tstate = wxPyBeginAllowThreads();
44173 wxItemContainer_SetClientData(arg1,arg2,arg3);
44174 wxPyEndAllowThreads(__tstate);
44175 if (PyErr_Occurred()) SWIG_fail;
44176 }
44177 resultobj = SWIG_Py_Void();
44178 return resultobj;
44179 fail:
44180 return NULL;
44181 }
44182
44183
44184 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44185 PyObject *resultobj = 0;
44186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44187 unsigned int result;
44188 void *argp1 = 0 ;
44189 int res1 = 0 ;
44190 PyObject *swig_obj[1] ;
44191
44192 if (!args) SWIG_fail;
44193 swig_obj[0] = args;
44194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44195 if (!SWIG_IsOK(res1)) {
44196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44197 }
44198 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44199 {
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44213 PyObject *resultobj = 0;
44214 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44215 bool result;
44216 void *argp1 = 0 ;
44217 int res1 = 0 ;
44218 PyObject *swig_obj[1] ;
44219
44220 if (!args) SWIG_fail;
44221 swig_obj[0] = args;
44222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44223 if (!SWIG_IsOK(res1)) {
44224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44225 }
44226 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44227 {
44228 PyThreadState* __tstate = wxPyBeginAllowThreads();
44229 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44230 wxPyEndAllowThreads(__tstate);
44231 if (PyErr_Occurred()) SWIG_fail;
44232 }
44233 {
44234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44235 }
44236 return resultobj;
44237 fail:
44238 return NULL;
44239 }
44240
44241
44242 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44243 PyObject *resultobj = 0;
44244 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44245 unsigned int arg2 ;
44246 wxString result;
44247 void *argp1 = 0 ;
44248 int res1 = 0 ;
44249 unsigned int val2 ;
44250 int ecode2 = 0 ;
44251 PyObject * obj0 = 0 ;
44252 PyObject * obj1 = 0 ;
44253 char * kwnames[] = {
44254 (char *) "self",(char *) "n", NULL
44255 };
44256
44257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44259 if (!SWIG_IsOK(res1)) {
44260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44261 }
44262 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44263 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44264 if (!SWIG_IsOK(ecode2)) {
44265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44266 }
44267 arg2 = static_cast< unsigned int >(val2);
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 {
44275 #if wxUSE_UNICODE
44276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44277 #else
44278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44279 #endif
44280 }
44281 return resultobj;
44282 fail:
44283 return NULL;
44284 }
44285
44286
44287 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44288 PyObject *resultobj = 0;
44289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44290 wxArrayString result;
44291 void *argp1 = 0 ;
44292 int res1 = 0 ;
44293 PyObject *swig_obj[1] ;
44294
44295 if (!args) SWIG_fail;
44296 swig_obj[0] = args;
44297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44298 if (!SWIG_IsOK(res1)) {
44299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44300 }
44301 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44302 {
44303 PyThreadState* __tstate = wxPyBeginAllowThreads();
44304 result = ((wxItemContainer const *)arg1)->GetStrings();
44305 wxPyEndAllowThreads(__tstate);
44306 if (PyErr_Occurred()) SWIG_fail;
44307 }
44308 {
44309 resultobj = wxArrayString2PyList_helper(result);
44310 }
44311 return resultobj;
44312 fail:
44313 return NULL;
44314 }
44315
44316
44317 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44318 PyObject *resultobj = 0;
44319 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44320 unsigned int arg2 ;
44321 wxString *arg3 = 0 ;
44322 void *argp1 = 0 ;
44323 int res1 = 0 ;
44324 unsigned int val2 ;
44325 int ecode2 = 0 ;
44326 bool temp3 = false ;
44327 PyObject * obj0 = 0 ;
44328 PyObject * obj1 = 0 ;
44329 PyObject * obj2 = 0 ;
44330 char * kwnames[] = {
44331 (char *) "self",(char *) "n",(char *) "s", NULL
44332 };
44333
44334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44336 if (!SWIG_IsOK(res1)) {
44337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44338 }
44339 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44340 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44341 if (!SWIG_IsOK(ecode2)) {
44342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44343 }
44344 arg2 = static_cast< unsigned int >(val2);
44345 {
44346 arg3 = wxString_in_helper(obj2);
44347 if (arg3 == NULL) SWIG_fail;
44348 temp3 = true;
44349 }
44350 {
44351 PyThreadState* __tstate = wxPyBeginAllowThreads();
44352 (arg1)->SetString(arg2,(wxString const &)*arg3);
44353 wxPyEndAllowThreads(__tstate);
44354 if (PyErr_Occurred()) SWIG_fail;
44355 }
44356 resultobj = SWIG_Py_Void();
44357 {
44358 if (temp3)
44359 delete arg3;
44360 }
44361 return resultobj;
44362 fail:
44363 {
44364 if (temp3)
44365 delete arg3;
44366 }
44367 return NULL;
44368 }
44369
44370
44371 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44372 PyObject *resultobj = 0;
44373 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44374 wxString *arg2 = 0 ;
44375 int result;
44376 void *argp1 = 0 ;
44377 int res1 = 0 ;
44378 bool temp2 = false ;
44379 PyObject * obj0 = 0 ;
44380 PyObject * obj1 = 0 ;
44381 char * kwnames[] = {
44382 (char *) "self",(char *) "s", NULL
44383 };
44384
44385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44387 if (!SWIG_IsOK(res1)) {
44388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44389 }
44390 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44391 {
44392 arg2 = wxString_in_helper(obj1);
44393 if (arg2 == NULL) SWIG_fail;
44394 temp2 = true;
44395 }
44396 {
44397 PyThreadState* __tstate = wxPyBeginAllowThreads();
44398 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44399 wxPyEndAllowThreads(__tstate);
44400 if (PyErr_Occurred()) SWIG_fail;
44401 }
44402 resultobj = SWIG_From_int(static_cast< int >(result));
44403 {
44404 if (temp2)
44405 delete arg2;
44406 }
44407 return resultobj;
44408 fail:
44409 {
44410 if (temp2)
44411 delete arg2;
44412 }
44413 return NULL;
44414 }
44415
44416
44417 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44418 PyObject *resultobj = 0;
44419 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44420 int arg2 ;
44421 void *argp1 = 0 ;
44422 int res1 = 0 ;
44423 int val2 ;
44424 int ecode2 = 0 ;
44425 PyObject * obj0 = 0 ;
44426 PyObject * obj1 = 0 ;
44427 char * kwnames[] = {
44428 (char *) "self",(char *) "n", NULL
44429 };
44430
44431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44433 if (!SWIG_IsOK(res1)) {
44434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44435 }
44436 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44437 ecode2 = SWIG_AsVal_int(obj1, &val2);
44438 if (!SWIG_IsOK(ecode2)) {
44439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44440 }
44441 arg2 = static_cast< int >(val2);
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 (arg1)->SetSelection(arg2);
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 resultobj = SWIG_Py_Void();
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44456 PyObject *resultobj = 0;
44457 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44458 int result;
44459 void *argp1 = 0 ;
44460 int res1 = 0 ;
44461 PyObject *swig_obj[1] ;
44462
44463 if (!args) SWIG_fail;
44464 swig_obj[0] = args;
44465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44466 if (!SWIG_IsOK(res1)) {
44467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44468 }
44469 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44470 {
44471 PyThreadState* __tstate = wxPyBeginAllowThreads();
44472 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 resultobj = SWIG_From_int(static_cast< int >(result));
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44484 PyObject *resultobj = 0;
44485 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44486 wxString *arg2 = 0 ;
44487 bool result;
44488 void *argp1 = 0 ;
44489 int res1 = 0 ;
44490 bool temp2 = false ;
44491 PyObject * obj0 = 0 ;
44492 PyObject * obj1 = 0 ;
44493 char * kwnames[] = {
44494 (char *) "self",(char *) "s", NULL
44495 };
44496
44497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44499 if (!SWIG_IsOK(res1)) {
44500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44501 }
44502 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44503 {
44504 arg2 = wxString_in_helper(obj1);
44505 if (arg2 == NULL) SWIG_fail;
44506 temp2 = true;
44507 }
44508 {
44509 PyThreadState* __tstate = wxPyBeginAllowThreads();
44510 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 {
44515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44516 }
44517 {
44518 if (temp2)
44519 delete arg2;
44520 }
44521 return resultobj;
44522 fail:
44523 {
44524 if (temp2)
44525 delete arg2;
44526 }
44527 return NULL;
44528 }
44529
44530
44531 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44532 PyObject *resultobj = 0;
44533 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44534 wxString result;
44535 void *argp1 = 0 ;
44536 int res1 = 0 ;
44537 PyObject *swig_obj[1] ;
44538
44539 if (!args) SWIG_fail;
44540 swig_obj[0] = args;
44541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44542 if (!SWIG_IsOK(res1)) {
44543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44544 }
44545 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 {
44553 #if wxUSE_UNICODE
44554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44555 #else
44556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44557 #endif
44558 }
44559 return resultobj;
44560 fail:
44561 return NULL;
44562 }
44563
44564
44565 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44566 PyObject *resultobj = 0;
44567 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44568 int arg2 ;
44569 void *argp1 = 0 ;
44570 int res1 = 0 ;
44571 int val2 ;
44572 int ecode2 = 0 ;
44573 PyObject * obj0 = 0 ;
44574 PyObject * obj1 = 0 ;
44575 char * kwnames[] = {
44576 (char *) "self",(char *) "n", NULL
44577 };
44578
44579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44581 if (!SWIG_IsOK(res1)) {
44582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44583 }
44584 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44585 ecode2 = SWIG_AsVal_int(obj1, &val2);
44586 if (!SWIG_IsOK(ecode2)) {
44587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44588 }
44589 arg2 = static_cast< int >(val2);
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 (arg1)->Select(arg2);
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 resultobj = SWIG_Py_Void();
44597 return resultobj;
44598 fail:
44599 return NULL;
44600 }
44601
44602
44603 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44604 PyObject *obj;
44605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44606 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44607 return SWIG_Py_Void();
44608 }
44609
44610 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44611 PyObject *obj;
44612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44613 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44614 return SWIG_Py_Void();
44615 }
44616
44617 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44618 PyObject *resultobj = 0;
44619 wxSizerItem *result = 0 ;
44620
44621 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44622 {
44623 PyThreadState* __tstate = wxPyBeginAllowThreads();
44624 result = (wxSizerItem *)new wxSizerItem();
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44636 PyObject *resultobj = 0;
44637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44638 void *argp1 = 0 ;
44639 int res1 = 0 ;
44640 PyObject *swig_obj[1] ;
44641
44642 if (!args) SWIG_fail;
44643 swig_obj[0] = args;
44644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44645 if (!SWIG_IsOK(res1)) {
44646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44647 }
44648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 delete arg1;
44652
44653 wxPyEndAllowThreads(__tstate);
44654 if (PyErr_Occurred()) SWIG_fail;
44655 }
44656 resultobj = SWIG_Py_Void();
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44664 PyObject *resultobj = 0;
44665 wxWindow *arg1 = (wxWindow *) 0 ;
44666 int arg2 ;
44667 int arg3 ;
44668 int arg4 ;
44669 PyObject *arg5 = (PyObject *) NULL ;
44670 wxSizerItem *result = 0 ;
44671 void *argp1 = 0 ;
44672 int res1 = 0 ;
44673 int val2 ;
44674 int ecode2 = 0 ;
44675 int val3 ;
44676 int ecode3 = 0 ;
44677 int val4 ;
44678 int ecode4 = 0 ;
44679 PyObject * obj0 = 0 ;
44680 PyObject * obj1 = 0 ;
44681 PyObject * obj2 = 0 ;
44682 PyObject * obj3 = 0 ;
44683 PyObject * obj4 = 0 ;
44684 char * kwnames[] = {
44685 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44686 };
44687
44688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44690 if (!SWIG_IsOK(res1)) {
44691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44692 }
44693 arg1 = reinterpret_cast< wxWindow * >(argp1);
44694 ecode2 = SWIG_AsVal_int(obj1, &val2);
44695 if (!SWIG_IsOK(ecode2)) {
44696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44697 }
44698 arg2 = static_cast< int >(val2);
44699 ecode3 = SWIG_AsVal_int(obj2, &val3);
44700 if (!SWIG_IsOK(ecode3)) {
44701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44702 }
44703 arg3 = static_cast< int >(val3);
44704 ecode4 = SWIG_AsVal_int(obj3, &val4);
44705 if (!SWIG_IsOK(ecode4)) {
44706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44707 }
44708 arg4 = static_cast< int >(val4);
44709 if (obj4) {
44710 arg5 = obj4;
44711 }
44712 {
44713 PyThreadState* __tstate = wxPyBeginAllowThreads();
44714 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44715 wxPyEndAllowThreads(__tstate);
44716 if (PyErr_Occurred()) SWIG_fail;
44717 }
44718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44726 PyObject *resultobj = 0;
44727 int arg1 ;
44728 int arg2 ;
44729 int arg3 ;
44730 int arg4 ;
44731 int arg5 ;
44732 PyObject *arg6 = (PyObject *) NULL ;
44733 wxSizerItem *result = 0 ;
44734 int val1 ;
44735 int ecode1 = 0 ;
44736 int val2 ;
44737 int ecode2 = 0 ;
44738 int val3 ;
44739 int ecode3 = 0 ;
44740 int val4 ;
44741 int ecode4 = 0 ;
44742 int val5 ;
44743 int ecode5 = 0 ;
44744 PyObject * obj0 = 0 ;
44745 PyObject * obj1 = 0 ;
44746 PyObject * obj2 = 0 ;
44747 PyObject * obj3 = 0 ;
44748 PyObject * obj4 = 0 ;
44749 PyObject * obj5 = 0 ;
44750 char * kwnames[] = {
44751 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44752 };
44753
44754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44755 ecode1 = SWIG_AsVal_int(obj0, &val1);
44756 if (!SWIG_IsOK(ecode1)) {
44757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44758 }
44759 arg1 = static_cast< int >(val1);
44760 ecode2 = SWIG_AsVal_int(obj1, &val2);
44761 if (!SWIG_IsOK(ecode2)) {
44762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44763 }
44764 arg2 = static_cast< int >(val2);
44765 ecode3 = SWIG_AsVal_int(obj2, &val3);
44766 if (!SWIG_IsOK(ecode3)) {
44767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44768 }
44769 arg3 = static_cast< int >(val3);
44770 ecode4 = SWIG_AsVal_int(obj3, &val4);
44771 if (!SWIG_IsOK(ecode4)) {
44772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44773 }
44774 arg4 = static_cast< int >(val4);
44775 ecode5 = SWIG_AsVal_int(obj4, &val5);
44776 if (!SWIG_IsOK(ecode5)) {
44777 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44778 }
44779 arg5 = static_cast< int >(val5);
44780 if (obj5) {
44781 arg6 = obj5;
44782 }
44783 {
44784 PyThreadState* __tstate = wxPyBeginAllowThreads();
44785 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj = 0;
44798 wxSizer *arg1 = (wxSizer *) 0 ;
44799 int arg2 ;
44800 int arg3 ;
44801 int arg4 ;
44802 PyObject *arg5 = (PyObject *) NULL ;
44803 wxSizerItem *result = 0 ;
44804 int res1 = 0 ;
44805 int val2 ;
44806 int ecode2 = 0 ;
44807 int val3 ;
44808 int ecode3 = 0 ;
44809 int val4 ;
44810 int ecode4 = 0 ;
44811 PyObject * obj0 = 0 ;
44812 PyObject * obj1 = 0 ;
44813 PyObject * obj2 = 0 ;
44814 PyObject * obj3 = 0 ;
44815 PyObject * obj4 = 0 ;
44816 char * kwnames[] = {
44817 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44818 };
44819
44820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44821 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44822 if (!SWIG_IsOK(res1)) {
44823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44824 }
44825 ecode2 = SWIG_AsVal_int(obj1, &val2);
44826 if (!SWIG_IsOK(ecode2)) {
44827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44828 }
44829 arg2 = static_cast< int >(val2);
44830 ecode3 = SWIG_AsVal_int(obj2, &val3);
44831 if (!SWIG_IsOK(ecode3)) {
44832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44833 }
44834 arg3 = static_cast< int >(val3);
44835 ecode4 = SWIG_AsVal_int(obj3, &val4);
44836 if (!SWIG_IsOK(ecode4)) {
44837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44838 }
44839 arg4 = static_cast< int >(val4);
44840 if (obj4) {
44841 arg5 = obj4;
44842 }
44843 {
44844 PyThreadState* __tstate = wxPyBeginAllowThreads();
44845 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44846 wxPyEndAllowThreads(__tstate);
44847 if (PyErr_Occurred()) SWIG_fail;
44848 }
44849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44850 return resultobj;
44851 fail:
44852 return NULL;
44853 }
44854
44855
44856 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44857 PyObject *resultobj = 0;
44858 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44859 void *argp1 = 0 ;
44860 int res1 = 0 ;
44861 PyObject *swig_obj[1] ;
44862
44863 if (!args) SWIG_fail;
44864 swig_obj[0] = args;
44865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44866 if (!SWIG_IsOK(res1)) {
44867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44868 }
44869 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44870 {
44871 PyThreadState* __tstate = wxPyBeginAllowThreads();
44872 (arg1)->DeleteWindows();
44873 wxPyEndAllowThreads(__tstate);
44874 if (PyErr_Occurred()) SWIG_fail;
44875 }
44876 resultobj = SWIG_Py_Void();
44877 return resultobj;
44878 fail:
44879 return NULL;
44880 }
44881
44882
44883 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44884 PyObject *resultobj = 0;
44885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44886 void *argp1 = 0 ;
44887 int res1 = 0 ;
44888 PyObject *swig_obj[1] ;
44889
44890 if (!args) SWIG_fail;
44891 swig_obj[0] = args;
44892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44893 if (!SWIG_IsOK(res1)) {
44894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44895 }
44896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 (arg1)->DetachSizer();
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_Py_Void();
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *resultobj = 0;
44912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44913 wxSize result;
44914 void *argp1 = 0 ;
44915 int res1 = 0 ;
44916 PyObject *swig_obj[1] ;
44917
44918 if (!args) SWIG_fail;
44919 swig_obj[0] = args;
44920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44921 if (!SWIG_IsOK(res1)) {
44922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44923 }
44924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 result = (arg1)->GetSize();
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44939 PyObject *resultobj = 0;
44940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44941 wxSize result;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 PyObject *swig_obj[1] ;
44945
44946 if (!args) SWIG_fail;
44947 swig_obj[0] = args;
44948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44949 if (!SWIG_IsOK(res1)) {
44950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44951 }
44952 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 result = (arg1)->CalcMin();
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44960 return resultobj;
44961 fail:
44962 return NULL;
44963 }
44964
44965
44966 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44967 PyObject *resultobj = 0;
44968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44969 wxPoint *arg2 = 0 ;
44970 wxSize *arg3 = 0 ;
44971 void *argp1 = 0 ;
44972 int res1 = 0 ;
44973 wxPoint temp2 ;
44974 wxSize temp3 ;
44975 PyObject * obj0 = 0 ;
44976 PyObject * obj1 = 0 ;
44977 PyObject * obj2 = 0 ;
44978 char * kwnames[] = {
44979 (char *) "self",(char *) "pos",(char *) "size", NULL
44980 };
44981
44982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44984 if (!SWIG_IsOK(res1)) {
44985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44986 }
44987 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44988 {
44989 arg2 = &temp2;
44990 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44991 }
44992 {
44993 arg3 = &temp3;
44994 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44995 }
44996 {
44997 PyThreadState* __tstate = wxPyBeginAllowThreads();
44998 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44999 wxPyEndAllowThreads(__tstate);
45000 if (PyErr_Occurred()) SWIG_fail;
45001 }
45002 resultobj = SWIG_Py_Void();
45003 return resultobj;
45004 fail:
45005 return NULL;
45006 }
45007
45008
45009 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45010 PyObject *resultobj = 0;
45011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45012 wxSize result;
45013 void *argp1 = 0 ;
45014 int res1 = 0 ;
45015 PyObject *swig_obj[1] ;
45016
45017 if (!args) SWIG_fail;
45018 swig_obj[0] = args;
45019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45020 if (!SWIG_IsOK(res1)) {
45021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45022 }
45023 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 result = (arg1)->GetMinSize();
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45031 return resultobj;
45032 fail:
45033 return NULL;
45034 }
45035
45036
45037 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45038 PyObject *resultobj = 0;
45039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45040 wxSize result;
45041 void *argp1 = 0 ;
45042 int res1 = 0 ;
45043 PyObject *swig_obj[1] ;
45044
45045 if (!args) SWIG_fail;
45046 swig_obj[0] = args;
45047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45048 if (!SWIG_IsOK(res1)) {
45049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45050 }
45051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45052 {
45053 PyThreadState* __tstate = wxPyBeginAllowThreads();
45054 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45055 wxPyEndAllowThreads(__tstate);
45056 if (PyErr_Occurred()) SWIG_fail;
45057 }
45058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45059 return resultobj;
45060 fail:
45061 return NULL;
45062 }
45063
45064
45065 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45066 PyObject *resultobj = 0;
45067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45068 int arg2 ;
45069 int arg3 ;
45070 void *argp1 = 0 ;
45071 int res1 = 0 ;
45072 int val2 ;
45073 int ecode2 = 0 ;
45074 int val3 ;
45075 int ecode3 = 0 ;
45076 PyObject * obj0 = 0 ;
45077 PyObject * obj1 = 0 ;
45078 PyObject * obj2 = 0 ;
45079 char * kwnames[] = {
45080 (char *) "self",(char *) "x",(char *) "y", NULL
45081 };
45082
45083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45085 if (!SWIG_IsOK(res1)) {
45086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45087 }
45088 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45089 ecode2 = SWIG_AsVal_int(obj1, &val2);
45090 if (!SWIG_IsOK(ecode2)) {
45091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', 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 '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45097 }
45098 arg3 = static_cast< int >(val3);
45099 {
45100 PyThreadState* __tstate = wxPyBeginAllowThreads();
45101 (arg1)->SetInitSize(arg2,arg3);
45102 wxPyEndAllowThreads(__tstate);
45103 if (PyErr_Occurred()) SWIG_fail;
45104 }
45105 resultobj = SWIG_Py_Void();
45106 return resultobj;
45107 fail:
45108 return NULL;
45109 }
45110
45111
45112 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45113 PyObject *resultobj = 0;
45114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45115 int arg2 ;
45116 int arg3 ;
45117 void *argp1 = 0 ;
45118 int res1 = 0 ;
45119 int val2 ;
45120 int ecode2 = 0 ;
45121 int val3 ;
45122 int ecode3 = 0 ;
45123 PyObject * obj0 = 0 ;
45124 PyObject * obj1 = 0 ;
45125 PyObject * obj2 = 0 ;
45126 char * kwnames[] = {
45127 (char *) "self",(char *) "width",(char *) "height", NULL
45128 };
45129
45130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45132 if (!SWIG_IsOK(res1)) {
45133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45134 }
45135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45136 ecode2 = SWIG_AsVal_int(obj1, &val2);
45137 if (!SWIG_IsOK(ecode2)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45139 }
45140 arg2 = static_cast< int >(val2);
45141 ecode3 = SWIG_AsVal_int(obj2, &val3);
45142 if (!SWIG_IsOK(ecode3)) {
45143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45144 }
45145 arg3 = static_cast< int >(val3);
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 (arg1)->SetRatio(arg2,arg3);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 resultobj = SWIG_Py_Void();
45153 return resultobj;
45154 fail:
45155 return NULL;
45156 }
45157
45158
45159 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45160 PyObject *resultobj = 0;
45161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45162 wxSize *arg2 = 0 ;
45163 void *argp1 = 0 ;
45164 int res1 = 0 ;
45165 wxSize temp2 ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "size", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45176 }
45177 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45178 {
45179 arg2 = &temp2;
45180 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45181 }
45182 {
45183 PyThreadState* __tstate = wxPyBeginAllowThreads();
45184 (arg1)->SetRatio((wxSize const &)*arg2);
45185 wxPyEndAllowThreads(__tstate);
45186 if (PyErr_Occurred()) SWIG_fail;
45187 }
45188 resultobj = SWIG_Py_Void();
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj = 0;
45197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45198 float arg2 ;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 float val2 ;
45202 int ecode2 = 0 ;
45203 PyObject * obj0 = 0 ;
45204 PyObject * obj1 = 0 ;
45205 char * kwnames[] = {
45206 (char *) "self",(char *) "ratio", NULL
45207 };
45208
45209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45211 if (!SWIG_IsOK(res1)) {
45212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45213 }
45214 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45215 ecode2 = SWIG_AsVal_float(obj1, &val2);
45216 if (!SWIG_IsOK(ecode2)) {
45217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45218 }
45219 arg2 = static_cast< float >(val2);
45220 {
45221 PyThreadState* __tstate = wxPyBeginAllowThreads();
45222 (arg1)->SetRatio(arg2);
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 resultobj = SWIG_Py_Void();
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45234 PyObject *resultobj = 0;
45235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45236 float result;
45237 void *argp1 = 0 ;
45238 int res1 = 0 ;
45239 PyObject *swig_obj[1] ;
45240
45241 if (!args) SWIG_fail;
45242 swig_obj[0] = args;
45243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45244 if (!SWIG_IsOK(res1)) {
45245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45246 }
45247 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45248 {
45249 PyThreadState* __tstate = wxPyBeginAllowThreads();
45250 result = (float)(arg1)->GetRatio();
45251 wxPyEndAllowThreads(__tstate);
45252 if (PyErr_Occurred()) SWIG_fail;
45253 }
45254 resultobj = SWIG_From_float(static_cast< float >(result));
45255 return resultobj;
45256 fail:
45257 return NULL;
45258 }
45259
45260
45261 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45262 PyObject *resultobj = 0;
45263 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45264 wxRect result;
45265 void *argp1 = 0 ;
45266 int res1 = 0 ;
45267 PyObject *swig_obj[1] ;
45268
45269 if (!args) SWIG_fail;
45270 swig_obj[0] = args;
45271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45272 if (!SWIG_IsOK(res1)) {
45273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45274 }
45275 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45276 {
45277 PyThreadState* __tstate = wxPyBeginAllowThreads();
45278 result = (arg1)->GetRect();
45279 wxPyEndAllowThreads(__tstate);
45280 if (PyErr_Occurred()) SWIG_fail;
45281 }
45282 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45283 return resultobj;
45284 fail:
45285 return NULL;
45286 }
45287
45288
45289 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45290 PyObject *resultobj = 0;
45291 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45292 bool result;
45293 void *argp1 = 0 ;
45294 int res1 = 0 ;
45295 PyObject *swig_obj[1] ;
45296
45297 if (!args) SWIG_fail;
45298 swig_obj[0] = args;
45299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45300 if (!SWIG_IsOK(res1)) {
45301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45302 }
45303 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 result = (bool)(arg1)->IsWindow();
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 {
45311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45312 }
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45320 PyObject *resultobj = 0;
45321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45322 bool result;
45323 void *argp1 = 0 ;
45324 int res1 = 0 ;
45325 PyObject *swig_obj[1] ;
45326
45327 if (!args) SWIG_fail;
45328 swig_obj[0] = args;
45329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45330 if (!SWIG_IsOK(res1)) {
45331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45332 }
45333 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45334 {
45335 PyThreadState* __tstate = wxPyBeginAllowThreads();
45336 result = (bool)(arg1)->IsSizer();
45337 wxPyEndAllowThreads(__tstate);
45338 if (PyErr_Occurred()) SWIG_fail;
45339 }
45340 {
45341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45342 }
45343 return resultobj;
45344 fail:
45345 return NULL;
45346 }
45347
45348
45349 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45350 PyObject *resultobj = 0;
45351 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45352 bool result;
45353 void *argp1 = 0 ;
45354 int res1 = 0 ;
45355 PyObject *swig_obj[1] ;
45356
45357 if (!args) SWIG_fail;
45358 swig_obj[0] = args;
45359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45360 if (!SWIG_IsOK(res1)) {
45361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45362 }
45363 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45364 {
45365 PyThreadState* __tstate = wxPyBeginAllowThreads();
45366 result = (bool)(arg1)->IsSpacer();
45367 wxPyEndAllowThreads(__tstate);
45368 if (PyErr_Occurred()) SWIG_fail;
45369 }
45370 {
45371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45372 }
45373 return resultobj;
45374 fail:
45375 return NULL;
45376 }
45377
45378
45379 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45380 PyObject *resultobj = 0;
45381 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45382 int arg2 ;
45383 void *argp1 = 0 ;
45384 int res1 = 0 ;
45385 int val2 ;
45386 int ecode2 = 0 ;
45387 PyObject * obj0 = 0 ;
45388 PyObject * obj1 = 0 ;
45389 char * kwnames[] = {
45390 (char *) "self",(char *) "proportion", NULL
45391 };
45392
45393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45395 if (!SWIG_IsOK(res1)) {
45396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45397 }
45398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45399 ecode2 = SWIG_AsVal_int(obj1, &val2);
45400 if (!SWIG_IsOK(ecode2)) {
45401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45402 }
45403 arg2 = static_cast< int >(val2);
45404 {
45405 PyThreadState* __tstate = wxPyBeginAllowThreads();
45406 (arg1)->SetProportion(arg2);
45407 wxPyEndAllowThreads(__tstate);
45408 if (PyErr_Occurred()) SWIG_fail;
45409 }
45410 resultobj = SWIG_Py_Void();
45411 return resultobj;
45412 fail:
45413 return NULL;
45414 }
45415
45416
45417 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45418 PyObject *resultobj = 0;
45419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45420 int result;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 PyObject *swig_obj[1] ;
45424
45425 if (!args) SWIG_fail;
45426 swig_obj[0] = args;
45427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45430 }
45431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = (int)(arg1)->GetProportion();
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 resultobj = SWIG_From_int(static_cast< int >(result));
45439 return resultobj;
45440 fail:
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45446 PyObject *resultobj = 0;
45447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45448 int arg2 ;
45449 void *argp1 = 0 ;
45450 int res1 = 0 ;
45451 int val2 ;
45452 int ecode2 = 0 ;
45453 PyObject * obj0 = 0 ;
45454 PyObject * obj1 = 0 ;
45455 char * kwnames[] = {
45456 (char *) "self",(char *) "flag", NULL
45457 };
45458
45459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) 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_SetFlag" "', 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_SetFlag" "', expected argument " "2"" of type '" "int""'");
45468 }
45469 arg2 = static_cast< int >(val2);
45470 {
45471 PyThreadState* __tstate = wxPyBeginAllowThreads();
45472 (arg1)->SetFlag(arg2);
45473 wxPyEndAllowThreads(__tstate);
45474 if (PyErr_Occurred()) SWIG_fail;
45475 }
45476 resultobj = SWIG_Py_Void();
45477 return resultobj;
45478 fail:
45479 return NULL;
45480 }
45481
45482
45483 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45484 PyObject *resultobj = 0;
45485 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45486 int result;
45487 void *argp1 = 0 ;
45488 int res1 = 0 ;
45489 PyObject *swig_obj[1] ;
45490
45491 if (!args) SWIG_fail;
45492 swig_obj[0] = args;
45493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45494 if (!SWIG_IsOK(res1)) {
45495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45496 }
45497 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45498 {
45499 PyThreadState* __tstate = wxPyBeginAllowThreads();
45500 result = (int)(arg1)->GetFlag();
45501 wxPyEndAllowThreads(__tstate);
45502 if (PyErr_Occurred()) SWIG_fail;
45503 }
45504 resultobj = SWIG_From_int(static_cast< int >(result));
45505 return resultobj;
45506 fail:
45507 return NULL;
45508 }
45509
45510
45511 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45512 PyObject *resultobj = 0;
45513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45514 int arg2 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 int val2 ;
45518 int ecode2 = 0 ;
45519 PyObject * obj0 = 0 ;
45520 PyObject * obj1 = 0 ;
45521 char * kwnames[] = {
45522 (char *) "self",(char *) "border", NULL
45523 };
45524
45525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45527 if (!SWIG_IsOK(res1)) {
45528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45529 }
45530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45531 ecode2 = SWIG_AsVal_int(obj1, &val2);
45532 if (!SWIG_IsOK(ecode2)) {
45533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45534 }
45535 arg2 = static_cast< int >(val2);
45536 {
45537 PyThreadState* __tstate = wxPyBeginAllowThreads();
45538 (arg1)->SetBorder(arg2);
45539 wxPyEndAllowThreads(__tstate);
45540 if (PyErr_Occurred()) SWIG_fail;
45541 }
45542 resultobj = SWIG_Py_Void();
45543 return resultobj;
45544 fail:
45545 return NULL;
45546 }
45547
45548
45549 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45550 PyObject *resultobj = 0;
45551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45552 int result;
45553 void *argp1 = 0 ;
45554 int res1 = 0 ;
45555 PyObject *swig_obj[1] ;
45556
45557 if (!args) SWIG_fail;
45558 swig_obj[0] = args;
45559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45560 if (!SWIG_IsOK(res1)) {
45561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45562 }
45563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 result = (int)(arg1)->GetBorder();
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 resultobj = SWIG_From_int(static_cast< int >(result));
45571 return resultobj;
45572 fail:
45573 return NULL;
45574 }
45575
45576
45577 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45578 PyObject *resultobj = 0;
45579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45580 wxWindow *result = 0 ;
45581 void *argp1 = 0 ;
45582 int res1 = 0 ;
45583 PyObject *swig_obj[1] ;
45584
45585 if (!args) SWIG_fail;
45586 swig_obj[0] = args;
45587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45588 if (!SWIG_IsOK(res1)) {
45589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45590 }
45591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45592 {
45593 PyThreadState* __tstate = wxPyBeginAllowThreads();
45594 result = (wxWindow *)(arg1)->GetWindow();
45595 wxPyEndAllowThreads(__tstate);
45596 if (PyErr_Occurred()) SWIG_fail;
45597 }
45598 {
45599 resultobj = wxPyMake_wxObject(result, 0);
45600 }
45601 return resultobj;
45602 fail:
45603 return NULL;
45604 }
45605
45606
45607 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45608 PyObject *resultobj = 0;
45609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45610 wxWindow *arg2 = (wxWindow *) 0 ;
45611 void *argp1 = 0 ;
45612 int res1 = 0 ;
45613 void *argp2 = 0 ;
45614 int res2 = 0 ;
45615 PyObject * obj0 = 0 ;
45616 PyObject * obj1 = 0 ;
45617 char * kwnames[] = {
45618 (char *) "self",(char *) "window", NULL
45619 };
45620
45621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45623 if (!SWIG_IsOK(res1)) {
45624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45625 }
45626 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45628 if (!SWIG_IsOK(res2)) {
45629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45630 }
45631 arg2 = reinterpret_cast< wxWindow * >(argp2);
45632 {
45633 PyThreadState* __tstate = wxPyBeginAllowThreads();
45634 (arg1)->SetWindow(arg2);
45635 wxPyEndAllowThreads(__tstate);
45636 if (PyErr_Occurred()) SWIG_fail;
45637 }
45638 resultobj = SWIG_Py_Void();
45639 return resultobj;
45640 fail:
45641 return NULL;
45642 }
45643
45644
45645 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45646 PyObject *resultobj = 0;
45647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45648 wxSizer *result = 0 ;
45649 void *argp1 = 0 ;
45650 int res1 = 0 ;
45651 PyObject *swig_obj[1] ;
45652
45653 if (!args) SWIG_fail;
45654 swig_obj[0] = args;
45655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45656 if (!SWIG_IsOK(res1)) {
45657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45658 }
45659 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 result = (wxSizer *)(arg1)->GetSizer();
45663 wxPyEndAllowThreads(__tstate);
45664 if (PyErr_Occurred()) SWIG_fail;
45665 }
45666 {
45667 resultobj = wxPyMake_wxObject(result, (bool)0);
45668 }
45669 return resultobj;
45670 fail:
45671 return NULL;
45672 }
45673
45674
45675 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45676 PyObject *resultobj = 0;
45677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45678 wxSizer *arg2 = (wxSizer *) 0 ;
45679 void *argp1 = 0 ;
45680 int res1 = 0 ;
45681 int res2 = 0 ;
45682 PyObject * obj0 = 0 ;
45683 PyObject * obj1 = 0 ;
45684 char * kwnames[] = {
45685 (char *) "self",(char *) "sizer", NULL
45686 };
45687
45688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45690 if (!SWIG_IsOK(res1)) {
45691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45692 }
45693 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45694 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45695 if (!SWIG_IsOK(res2)) {
45696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45697 }
45698 {
45699 PyThreadState* __tstate = wxPyBeginAllowThreads();
45700 (arg1)->SetSizer(arg2);
45701 wxPyEndAllowThreads(__tstate);
45702 if (PyErr_Occurred()) SWIG_fail;
45703 }
45704 resultobj = SWIG_Py_Void();
45705 return resultobj;
45706 fail:
45707 return NULL;
45708 }
45709
45710
45711 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45712 PyObject *resultobj = 0;
45713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45714 wxSize *result = 0 ;
45715 void *argp1 = 0 ;
45716 int res1 = 0 ;
45717 PyObject *swig_obj[1] ;
45718
45719 if (!args) SWIG_fail;
45720 swig_obj[0] = args;
45721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45722 if (!SWIG_IsOK(res1)) {
45723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45724 }
45725 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 {
45729 wxSize const &_result_ref = (arg1)->GetSpacer();
45730 result = (wxSize *) &_result_ref;
45731 }
45732 wxPyEndAllowThreads(__tstate);
45733 if (PyErr_Occurred()) SWIG_fail;
45734 }
45735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45736 return resultobj;
45737 fail:
45738 return NULL;
45739 }
45740
45741
45742 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45743 PyObject *resultobj = 0;
45744 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45745 wxSize *arg2 = 0 ;
45746 void *argp1 = 0 ;
45747 int res1 = 0 ;
45748 wxSize temp2 ;
45749 PyObject * obj0 = 0 ;
45750 PyObject * obj1 = 0 ;
45751 char * kwnames[] = {
45752 (char *) "self",(char *) "size", NULL
45753 };
45754
45755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45757 if (!SWIG_IsOK(res1)) {
45758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45759 }
45760 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45761 {
45762 arg2 = &temp2;
45763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45764 }
45765 {
45766 PyThreadState* __tstate = wxPyBeginAllowThreads();
45767 (arg1)->SetSpacer((wxSize const &)*arg2);
45768 wxPyEndAllowThreads(__tstate);
45769 if (PyErr_Occurred()) SWIG_fail;
45770 }
45771 resultobj = SWIG_Py_Void();
45772 return resultobj;
45773 fail:
45774 return NULL;
45775 }
45776
45777
45778 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45779 PyObject *resultobj = 0;
45780 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45781 bool arg2 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 bool val2 ;
45785 int ecode2 = 0 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "show", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45796 }
45797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45799 if (!SWIG_IsOK(ecode2)) {
45800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45801 }
45802 arg2 = static_cast< bool >(val2);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 (arg1)->Show(arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = SWIG_Py_Void();
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45817 PyObject *resultobj = 0;
45818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45819 bool result;
45820 void *argp1 = 0 ;
45821 int res1 = 0 ;
45822 PyObject *swig_obj[1] ;
45823
45824 if (!args) SWIG_fail;
45825 swig_obj[0] = args;
45826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45827 if (!SWIG_IsOK(res1)) {
45828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45829 }
45830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 result = (bool)(arg1)->IsShown();
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 {
45838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45839 }
45840 return resultobj;
45841 fail:
45842 return NULL;
45843 }
45844
45845
45846 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45847 PyObject *resultobj = 0;
45848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45849 wxPoint result;
45850 void *argp1 = 0 ;
45851 int res1 = 0 ;
45852 PyObject *swig_obj[1] ;
45853
45854 if (!args) SWIG_fail;
45855 swig_obj[0] = args;
45856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45857 if (!SWIG_IsOK(res1)) {
45858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45859 }
45860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45861 {
45862 PyThreadState* __tstate = wxPyBeginAllowThreads();
45863 result = (arg1)->GetPosition();
45864 wxPyEndAllowThreads(__tstate);
45865 if (PyErr_Occurred()) SWIG_fail;
45866 }
45867 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45868 return resultobj;
45869 fail:
45870 return NULL;
45871 }
45872
45873
45874 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45875 PyObject *resultobj = 0;
45876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45877 PyObject *result = 0 ;
45878 void *argp1 = 0 ;
45879 int res1 = 0 ;
45880 PyObject *swig_obj[1] ;
45881
45882 if (!args) SWIG_fail;
45883 swig_obj[0] = args;
45884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45885 if (!SWIG_IsOK(res1)) {
45886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45887 }
45888 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45889 {
45890 PyThreadState* __tstate = wxPyBeginAllowThreads();
45891 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45892 wxPyEndAllowThreads(__tstate);
45893 if (PyErr_Occurred()) SWIG_fail;
45894 }
45895 resultobj = result;
45896 return resultobj;
45897 fail:
45898 return NULL;
45899 }
45900
45901
45902 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45903 PyObject *resultobj = 0;
45904 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45905 PyObject *arg2 = (PyObject *) 0 ;
45906 void *argp1 = 0 ;
45907 int res1 = 0 ;
45908 PyObject * obj0 = 0 ;
45909 PyObject * obj1 = 0 ;
45910 char * kwnames[] = {
45911 (char *) "self",(char *) "userData", NULL
45912 };
45913
45914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45916 if (!SWIG_IsOK(res1)) {
45917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45918 }
45919 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45920 arg2 = obj1;
45921 {
45922 PyThreadState* __tstate = wxPyBeginAllowThreads();
45923 wxSizerItem_SetUserData(arg1,arg2);
45924 wxPyEndAllowThreads(__tstate);
45925 if (PyErr_Occurred()) SWIG_fail;
45926 }
45927 resultobj = SWIG_Py_Void();
45928 return resultobj;
45929 fail:
45930 return NULL;
45931 }
45932
45933
45934 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45935 PyObject *obj;
45936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45937 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45938 return SWIG_Py_Void();
45939 }
45940
45941 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45942 return SWIG_Python_InitShadowInstance(args);
45943 }
45944
45945 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45946 PyObject *resultobj = 0;
45947 wxSizer *arg1 = (wxSizer *) 0 ;
45948 void *argp1 = 0 ;
45949 int res1 = 0 ;
45950 PyObject *swig_obj[1] ;
45951
45952 if (!args) SWIG_fail;
45953 swig_obj[0] = args;
45954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45955 if (!SWIG_IsOK(res1)) {
45956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45957 }
45958 arg1 = reinterpret_cast< wxSizer * >(argp1);
45959 {
45960 PyThreadState* __tstate = wxPyBeginAllowThreads();
45961 delete arg1;
45962
45963 wxPyEndAllowThreads(__tstate);
45964 if (PyErr_Occurred()) SWIG_fail;
45965 }
45966 resultobj = SWIG_Py_Void();
45967 return resultobj;
45968 fail:
45969 return NULL;
45970 }
45971
45972
45973 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45974 PyObject *resultobj = 0;
45975 wxSizer *arg1 = (wxSizer *) 0 ;
45976 PyObject *arg2 = (PyObject *) 0 ;
45977 void *argp1 = 0 ;
45978 int res1 = 0 ;
45979 PyObject * obj0 = 0 ;
45980 PyObject * obj1 = 0 ;
45981 char * kwnames[] = {
45982 (char *) "self",(char *) "_self", NULL
45983 };
45984
45985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45987 if (!SWIG_IsOK(res1)) {
45988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45989 }
45990 arg1 = reinterpret_cast< wxSizer * >(argp1);
45991 arg2 = obj1;
45992 {
45993 PyThreadState* __tstate = wxPyBeginAllowThreads();
45994 wxSizer__setOORInfo(arg1,arg2);
45995 wxPyEndAllowThreads(__tstate);
45996 if (PyErr_Occurred()) SWIG_fail;
45997 }
45998 resultobj = SWIG_Py_Void();
45999 return resultobj;
46000 fail:
46001 return NULL;
46002 }
46003
46004
46005 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46006 PyObject *resultobj = 0;
46007 wxSizer *arg1 = (wxSizer *) 0 ;
46008 PyObject *arg2 = (PyObject *) 0 ;
46009 int arg3 = (int) 0 ;
46010 int arg4 = (int) 0 ;
46011 int arg5 = (int) 0 ;
46012 PyObject *arg6 = (PyObject *) NULL ;
46013 wxSizerItem *result = 0 ;
46014 void *argp1 = 0 ;
46015 int res1 = 0 ;
46016 int val3 ;
46017 int ecode3 = 0 ;
46018 int val4 ;
46019 int ecode4 = 0 ;
46020 int val5 ;
46021 int ecode5 = 0 ;
46022 PyObject * obj0 = 0 ;
46023 PyObject * obj1 = 0 ;
46024 PyObject * obj2 = 0 ;
46025 PyObject * obj3 = 0 ;
46026 PyObject * obj4 = 0 ;
46027 PyObject * obj5 = 0 ;
46028 char * kwnames[] = {
46029 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46030 };
46031
46032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46034 if (!SWIG_IsOK(res1)) {
46035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46036 }
46037 arg1 = reinterpret_cast< wxSizer * >(argp1);
46038 arg2 = obj1;
46039 if (obj2) {
46040 ecode3 = SWIG_AsVal_int(obj2, &val3);
46041 if (!SWIG_IsOK(ecode3)) {
46042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46043 }
46044 arg3 = static_cast< int >(val3);
46045 }
46046 if (obj3) {
46047 ecode4 = SWIG_AsVal_int(obj3, &val4);
46048 if (!SWIG_IsOK(ecode4)) {
46049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46050 }
46051 arg4 = static_cast< int >(val4);
46052 }
46053 if (obj4) {
46054 ecode5 = SWIG_AsVal_int(obj4, &val5);
46055 if (!SWIG_IsOK(ecode5)) {
46056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46057 }
46058 arg5 = static_cast< int >(val5);
46059 }
46060 if (obj5) {
46061 arg6 = obj5;
46062 }
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46077 PyObject *resultobj = 0;
46078 wxSizer *arg1 = (wxSizer *) 0 ;
46079 int arg2 ;
46080 PyObject *arg3 = (PyObject *) 0 ;
46081 int arg4 = (int) 0 ;
46082 int arg5 = (int) 0 ;
46083 int arg6 = (int) 0 ;
46084 PyObject *arg7 = (PyObject *) NULL ;
46085 wxSizerItem *result = 0 ;
46086 void *argp1 = 0 ;
46087 int res1 = 0 ;
46088 int val2 ;
46089 int ecode2 = 0 ;
46090 int val4 ;
46091 int ecode4 = 0 ;
46092 int val5 ;
46093 int ecode5 = 0 ;
46094 int val6 ;
46095 int ecode6 = 0 ;
46096 PyObject * obj0 = 0 ;
46097 PyObject * obj1 = 0 ;
46098 PyObject * obj2 = 0 ;
46099 PyObject * obj3 = 0 ;
46100 PyObject * obj4 = 0 ;
46101 PyObject * obj5 = 0 ;
46102 PyObject * obj6 = 0 ;
46103 char * kwnames[] = {
46104 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46105 };
46106
46107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46109 if (!SWIG_IsOK(res1)) {
46110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46111 }
46112 arg1 = reinterpret_cast< wxSizer * >(argp1);
46113 ecode2 = SWIG_AsVal_int(obj1, &val2);
46114 if (!SWIG_IsOK(ecode2)) {
46115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46116 }
46117 arg2 = static_cast< int >(val2);
46118 arg3 = obj2;
46119 if (obj3) {
46120 ecode4 = SWIG_AsVal_int(obj3, &val4);
46121 if (!SWIG_IsOK(ecode4)) {
46122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46123 }
46124 arg4 = static_cast< int >(val4);
46125 }
46126 if (obj4) {
46127 ecode5 = SWIG_AsVal_int(obj4, &val5);
46128 if (!SWIG_IsOK(ecode5)) {
46129 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46130 }
46131 arg5 = static_cast< int >(val5);
46132 }
46133 if (obj5) {
46134 ecode6 = SWIG_AsVal_int(obj5, &val6);
46135 if (!SWIG_IsOK(ecode6)) {
46136 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46137 }
46138 arg6 = static_cast< int >(val6);
46139 }
46140 if (obj6) {
46141 arg7 = obj6;
46142 }
46143 {
46144 PyThreadState* __tstate = wxPyBeginAllowThreads();
46145 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46146 wxPyEndAllowThreads(__tstate);
46147 if (PyErr_Occurred()) SWIG_fail;
46148 }
46149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46150 return resultobj;
46151 fail:
46152 return NULL;
46153 }
46154
46155
46156 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46157 PyObject *resultobj = 0;
46158 wxSizer *arg1 = (wxSizer *) 0 ;
46159 PyObject *arg2 = (PyObject *) 0 ;
46160 int arg3 = (int) 0 ;
46161 int arg4 = (int) 0 ;
46162 int arg5 = (int) 0 ;
46163 PyObject *arg6 = (PyObject *) NULL ;
46164 wxSizerItem *result = 0 ;
46165 void *argp1 = 0 ;
46166 int res1 = 0 ;
46167 int val3 ;
46168 int ecode3 = 0 ;
46169 int val4 ;
46170 int ecode4 = 0 ;
46171 int val5 ;
46172 int ecode5 = 0 ;
46173 PyObject * obj0 = 0 ;
46174 PyObject * obj1 = 0 ;
46175 PyObject * obj2 = 0 ;
46176 PyObject * obj3 = 0 ;
46177 PyObject * obj4 = 0 ;
46178 PyObject * obj5 = 0 ;
46179 char * kwnames[] = {
46180 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46181 };
46182
46183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46185 if (!SWIG_IsOK(res1)) {
46186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46187 }
46188 arg1 = reinterpret_cast< wxSizer * >(argp1);
46189 arg2 = obj1;
46190 if (obj2) {
46191 ecode3 = SWIG_AsVal_int(obj2, &val3);
46192 if (!SWIG_IsOK(ecode3)) {
46193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46194 }
46195 arg3 = static_cast< int >(val3);
46196 }
46197 if (obj3) {
46198 ecode4 = SWIG_AsVal_int(obj3, &val4);
46199 if (!SWIG_IsOK(ecode4)) {
46200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46201 }
46202 arg4 = static_cast< int >(val4);
46203 }
46204 if (obj4) {
46205 ecode5 = SWIG_AsVal_int(obj4, &val5);
46206 if (!SWIG_IsOK(ecode5)) {
46207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46208 }
46209 arg5 = static_cast< int >(val5);
46210 }
46211 if (obj5) {
46212 arg6 = obj5;
46213 }
46214 {
46215 PyThreadState* __tstate = wxPyBeginAllowThreads();
46216 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46217 wxPyEndAllowThreads(__tstate);
46218 if (PyErr_Occurred()) SWIG_fail;
46219 }
46220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46228 PyObject *resultobj = 0;
46229 wxSizer *arg1 = (wxSizer *) 0 ;
46230 PyObject *arg2 = (PyObject *) 0 ;
46231 bool result;
46232 void *argp1 = 0 ;
46233 int res1 = 0 ;
46234 PyObject * obj0 = 0 ;
46235 PyObject * obj1 = 0 ;
46236 char * kwnames[] = {
46237 (char *) "self",(char *) "item", NULL
46238 };
46239
46240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46242 if (!SWIG_IsOK(res1)) {
46243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46244 }
46245 arg1 = reinterpret_cast< wxSizer * >(argp1);
46246 arg2 = obj1;
46247 {
46248 PyThreadState* __tstate = wxPyBeginAllowThreads();
46249 result = (bool)wxSizer_Remove(arg1,arg2);
46250 wxPyEndAllowThreads(__tstate);
46251 if (PyErr_Occurred()) SWIG_fail;
46252 }
46253 {
46254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46255 }
46256 return resultobj;
46257 fail:
46258 return NULL;
46259 }
46260
46261
46262 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46263 PyObject *resultobj = 0;
46264 wxSizer *arg1 = (wxSizer *) 0 ;
46265 PyObject *arg2 = (PyObject *) 0 ;
46266 bool result;
46267 void *argp1 = 0 ;
46268 int res1 = 0 ;
46269 PyObject * obj0 = 0 ;
46270 PyObject * obj1 = 0 ;
46271 char * kwnames[] = {
46272 (char *) "self",(char *) "item", NULL
46273 };
46274
46275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46277 if (!SWIG_IsOK(res1)) {
46278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46279 }
46280 arg1 = reinterpret_cast< wxSizer * >(argp1);
46281 arg2 = obj1;
46282 {
46283 PyThreadState* __tstate = wxPyBeginAllowThreads();
46284 result = (bool)wxSizer_Detach(arg1,arg2);
46285 wxPyEndAllowThreads(__tstate);
46286 if (PyErr_Occurred()) SWIG_fail;
46287 }
46288 {
46289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46290 }
46291 return resultobj;
46292 fail:
46293 return NULL;
46294 }
46295
46296
46297 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46298 PyObject *resultobj = 0;
46299 wxSizer *arg1 = (wxSizer *) 0 ;
46300 PyObject *arg2 = (PyObject *) 0 ;
46301 wxSizerItem *result = 0 ;
46302 void *argp1 = 0 ;
46303 int res1 = 0 ;
46304 PyObject * obj0 = 0 ;
46305 PyObject * obj1 = 0 ;
46306 char * kwnames[] = {
46307 (char *) "self",(char *) "item", NULL
46308 };
46309
46310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46312 if (!SWIG_IsOK(res1)) {
46313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46314 }
46315 arg1 = reinterpret_cast< wxSizer * >(argp1);
46316 arg2 = obj1;
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46324 return resultobj;
46325 fail:
46326 return NULL;
46327 }
46328
46329
46330 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46331 PyObject *resultobj = 0;
46332 wxSizer *arg1 = (wxSizer *) 0 ;
46333 PyObject *arg2 = (PyObject *) 0 ;
46334 wxSize *arg3 = 0 ;
46335 void *argp1 = 0 ;
46336 int res1 = 0 ;
46337 wxSize temp3 ;
46338 PyObject * obj0 = 0 ;
46339 PyObject * obj1 = 0 ;
46340 PyObject * obj2 = 0 ;
46341 char * kwnames[] = {
46342 (char *) "self",(char *) "item",(char *) "size", NULL
46343 };
46344
46345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46347 if (!SWIG_IsOK(res1)) {
46348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46349 }
46350 arg1 = reinterpret_cast< wxSizer * >(argp1);
46351 arg2 = obj1;
46352 {
46353 arg3 = &temp3;
46354 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46355 }
46356 {
46357 PyThreadState* __tstate = wxPyBeginAllowThreads();
46358 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46359 wxPyEndAllowThreads(__tstate);
46360 if (PyErr_Occurred()) SWIG_fail;
46361 }
46362 resultobj = SWIG_Py_Void();
46363 return resultobj;
46364 fail:
46365 return NULL;
46366 }
46367
46368
46369 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46370 PyObject *resultobj = 0;
46371 wxSizer *arg1 = (wxSizer *) 0 ;
46372 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46373 wxSizerItem *result = 0 ;
46374 void *argp1 = 0 ;
46375 int res1 = 0 ;
46376 int res2 = 0 ;
46377 PyObject * obj0 = 0 ;
46378 PyObject * obj1 = 0 ;
46379 char * kwnames[] = {
46380 (char *) "self",(char *) "item", NULL
46381 };
46382
46383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46385 if (!SWIG_IsOK(res1)) {
46386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46387 }
46388 arg1 = reinterpret_cast< wxSizer * >(argp1);
46389 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46390 if (!SWIG_IsOK(res2)) {
46391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46392 }
46393 {
46394 PyThreadState* __tstate = wxPyBeginAllowThreads();
46395 result = (wxSizerItem *)(arg1)->Add(arg2);
46396 wxPyEndAllowThreads(__tstate);
46397 if (PyErr_Occurred()) SWIG_fail;
46398 }
46399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46400 return resultobj;
46401 fail:
46402 return NULL;
46403 }
46404
46405
46406 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46407 PyObject *resultobj = 0;
46408 wxSizer *arg1 = (wxSizer *) 0 ;
46409 size_t arg2 ;
46410 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46411 wxSizerItem *result = 0 ;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 size_t val2 ;
46415 int ecode2 = 0 ;
46416 int res3 = 0 ;
46417 PyObject * obj0 = 0 ;
46418 PyObject * obj1 = 0 ;
46419 PyObject * obj2 = 0 ;
46420 char * kwnames[] = {
46421 (char *) "self",(char *) "index",(char *) "item", NULL
46422 };
46423
46424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46426 if (!SWIG_IsOK(res1)) {
46427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46428 }
46429 arg1 = reinterpret_cast< wxSizer * >(argp1);
46430 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46431 if (!SWIG_IsOK(ecode2)) {
46432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46433 }
46434 arg2 = static_cast< size_t >(val2);
46435 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46436 if (!SWIG_IsOK(res3)) {
46437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46438 }
46439 {
46440 PyThreadState* __tstate = wxPyBeginAllowThreads();
46441 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46442 wxPyEndAllowThreads(__tstate);
46443 if (PyErr_Occurred()) SWIG_fail;
46444 }
46445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46446 return resultobj;
46447 fail:
46448 return NULL;
46449 }
46450
46451
46452 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46453 PyObject *resultobj = 0;
46454 wxSizer *arg1 = (wxSizer *) 0 ;
46455 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46456 wxSizerItem *result = 0 ;
46457 void *argp1 = 0 ;
46458 int res1 = 0 ;
46459 int res2 = 0 ;
46460 PyObject * obj0 = 0 ;
46461 PyObject * obj1 = 0 ;
46462 char * kwnames[] = {
46463 (char *) "self",(char *) "item", NULL
46464 };
46465
46466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46468 if (!SWIG_IsOK(res1)) {
46469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46470 }
46471 arg1 = reinterpret_cast< wxSizer * >(argp1);
46472 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46473 if (!SWIG_IsOK(res2)) {
46474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46475 }
46476 {
46477 PyThreadState* __tstate = wxPyBeginAllowThreads();
46478 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46479 wxPyEndAllowThreads(__tstate);
46480 if (PyErr_Occurred()) SWIG_fail;
46481 }
46482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46483 return resultobj;
46484 fail:
46485 return NULL;
46486 }
46487
46488
46489 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46490 PyObject *resultobj = 0;
46491 wxSizer *arg1 = (wxSizer *) 0 ;
46492 int arg2 ;
46493 int arg3 ;
46494 int arg4 ;
46495 int arg5 ;
46496 void *argp1 = 0 ;
46497 int res1 = 0 ;
46498 int val2 ;
46499 int ecode2 = 0 ;
46500 int val3 ;
46501 int ecode3 = 0 ;
46502 int val4 ;
46503 int ecode4 = 0 ;
46504 int val5 ;
46505 int ecode5 = 0 ;
46506 PyObject * obj0 = 0 ;
46507 PyObject * obj1 = 0 ;
46508 PyObject * obj2 = 0 ;
46509 PyObject * obj3 = 0 ;
46510 PyObject * obj4 = 0 ;
46511 char * kwnames[] = {
46512 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46513 };
46514
46515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46517 if (!SWIG_IsOK(res1)) {
46518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46519 }
46520 arg1 = reinterpret_cast< wxSizer * >(argp1);
46521 ecode2 = SWIG_AsVal_int(obj1, &val2);
46522 if (!SWIG_IsOK(ecode2)) {
46523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46524 }
46525 arg2 = static_cast< int >(val2);
46526 ecode3 = SWIG_AsVal_int(obj2, &val3);
46527 if (!SWIG_IsOK(ecode3)) {
46528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46529 }
46530 arg3 = static_cast< int >(val3);
46531 ecode4 = SWIG_AsVal_int(obj3, &val4);
46532 if (!SWIG_IsOK(ecode4)) {
46533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46534 }
46535 arg4 = static_cast< int >(val4);
46536 ecode5 = SWIG_AsVal_int(obj4, &val5);
46537 if (!SWIG_IsOK(ecode5)) {
46538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46539 }
46540 arg5 = static_cast< int >(val5);
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_Py_Void();
46548 return resultobj;
46549 fail:
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46555 PyObject *resultobj = 0;
46556 wxSizer *arg1 = (wxSizer *) 0 ;
46557 wxSize *arg2 = 0 ;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 wxSize temp2 ;
46561 PyObject * obj0 = 0 ;
46562 PyObject * obj1 = 0 ;
46563 char * kwnames[] = {
46564 (char *) "self",(char *) "size", NULL
46565 };
46566
46567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46569 if (!SWIG_IsOK(res1)) {
46570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46571 }
46572 arg1 = reinterpret_cast< wxSizer * >(argp1);
46573 {
46574 arg2 = &temp2;
46575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46576 }
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 (arg1)->SetMinSize((wxSize const &)*arg2);
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_Py_Void();
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46591 PyObject *resultobj = 0;
46592 wxSizer *arg1 = (wxSizer *) 0 ;
46593 wxSize result;
46594 void *argp1 = 0 ;
46595 int res1 = 0 ;
46596 PyObject *swig_obj[1] ;
46597
46598 if (!args) SWIG_fail;
46599 swig_obj[0] = args;
46600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46601 if (!SWIG_IsOK(res1)) {
46602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46603 }
46604 arg1 = reinterpret_cast< wxSizer * >(argp1);
46605 {
46606 PyThreadState* __tstate = wxPyBeginAllowThreads();
46607 result = (arg1)->GetSize();
46608 wxPyEndAllowThreads(__tstate);
46609 if (PyErr_Occurred()) SWIG_fail;
46610 }
46611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46612 return resultobj;
46613 fail:
46614 return NULL;
46615 }
46616
46617
46618 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46619 PyObject *resultobj = 0;
46620 wxSizer *arg1 = (wxSizer *) 0 ;
46621 wxPoint result;
46622 void *argp1 = 0 ;
46623 int res1 = 0 ;
46624 PyObject *swig_obj[1] ;
46625
46626 if (!args) SWIG_fail;
46627 swig_obj[0] = args;
46628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46629 if (!SWIG_IsOK(res1)) {
46630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46631 }
46632 arg1 = reinterpret_cast< wxSizer * >(argp1);
46633 {
46634 PyThreadState* __tstate = wxPyBeginAllowThreads();
46635 result = (arg1)->GetPosition();
46636 wxPyEndAllowThreads(__tstate);
46637 if (PyErr_Occurred()) SWIG_fail;
46638 }
46639 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46640 return resultobj;
46641 fail:
46642 return NULL;
46643 }
46644
46645
46646 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46647 PyObject *resultobj = 0;
46648 wxSizer *arg1 = (wxSizer *) 0 ;
46649 wxSize result;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 PyObject *swig_obj[1] ;
46653
46654 if (!args) SWIG_fail;
46655 swig_obj[0] = args;
46656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46659 }
46660 arg1 = reinterpret_cast< wxSizer * >(argp1);
46661 {
46662 PyThreadState* __tstate = wxPyBeginAllowThreads();
46663 result = (arg1)->GetMinSize();
46664 wxPyEndAllowThreads(__tstate);
46665 if (PyErr_Occurred()) SWIG_fail;
46666 }
46667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46668 return resultobj;
46669 fail:
46670 return NULL;
46671 }
46672
46673
46674 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46675 PyObject *resultobj = 0;
46676 wxSizer *arg1 = (wxSizer *) 0 ;
46677 void *argp1 = 0 ;
46678 int res1 = 0 ;
46679 PyObject *swig_obj[1] ;
46680
46681 if (!args) SWIG_fail;
46682 swig_obj[0] = args;
46683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46686 }
46687 arg1 = reinterpret_cast< wxSizer * >(argp1);
46688 {
46689 PyThreadState* __tstate = wxPyBeginAllowThreads();
46690 (arg1)->RecalcSizes();
46691 wxPyEndAllowThreads(__tstate);
46692 if (PyErr_Occurred()) SWIG_fail;
46693 }
46694 resultobj = SWIG_Py_Void();
46695 return resultobj;
46696 fail:
46697 return NULL;
46698 }
46699
46700
46701 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46702 PyObject *resultobj = 0;
46703 wxSizer *arg1 = (wxSizer *) 0 ;
46704 wxSize result;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 PyObject *swig_obj[1] ;
46708
46709 if (!args) SWIG_fail;
46710 swig_obj[0] = args;
46711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46712 if (!SWIG_IsOK(res1)) {
46713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46714 }
46715 arg1 = reinterpret_cast< wxSizer * >(argp1);
46716 {
46717 PyThreadState* __tstate = wxPyBeginAllowThreads();
46718 result = (arg1)->CalcMin();
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46723 return resultobj;
46724 fail:
46725 return NULL;
46726 }
46727
46728
46729 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46730 PyObject *resultobj = 0;
46731 wxSizer *arg1 = (wxSizer *) 0 ;
46732 void *argp1 = 0 ;
46733 int res1 = 0 ;
46734 PyObject *swig_obj[1] ;
46735
46736 if (!args) SWIG_fail;
46737 swig_obj[0] = args;
46738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46739 if (!SWIG_IsOK(res1)) {
46740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46741 }
46742 arg1 = reinterpret_cast< wxSizer * >(argp1);
46743 {
46744 PyThreadState* __tstate = wxPyBeginAllowThreads();
46745 (arg1)->Layout();
46746 wxPyEndAllowThreads(__tstate);
46747 if (PyErr_Occurred()) SWIG_fail;
46748 }
46749 resultobj = SWIG_Py_Void();
46750 return resultobj;
46751 fail:
46752 return NULL;
46753 }
46754
46755
46756 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46757 PyObject *resultobj = 0;
46758 wxSizer *arg1 = (wxSizer *) 0 ;
46759 wxWindow *arg2 = (wxWindow *) 0 ;
46760 wxSize result;
46761 void *argp1 = 0 ;
46762 int res1 = 0 ;
46763 void *argp2 = 0 ;
46764 int res2 = 0 ;
46765 PyObject * obj0 = 0 ;
46766 PyObject * obj1 = 0 ;
46767 char * kwnames[] = {
46768 (char *) "self",(char *) "window", NULL
46769 };
46770
46771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46773 if (!SWIG_IsOK(res1)) {
46774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46775 }
46776 arg1 = reinterpret_cast< wxSizer * >(argp1);
46777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46778 if (!SWIG_IsOK(res2)) {
46779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46780 }
46781 arg2 = reinterpret_cast< wxWindow * >(argp2);
46782 {
46783 PyThreadState* __tstate = wxPyBeginAllowThreads();
46784 result = (arg1)->Fit(arg2);
46785 wxPyEndAllowThreads(__tstate);
46786 if (PyErr_Occurred()) SWIG_fail;
46787 }
46788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46789 return resultobj;
46790 fail:
46791 return NULL;
46792 }
46793
46794
46795 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46796 PyObject *resultobj = 0;
46797 wxSizer *arg1 = (wxSizer *) 0 ;
46798 wxWindow *arg2 = (wxWindow *) 0 ;
46799 void *argp1 = 0 ;
46800 int res1 = 0 ;
46801 void *argp2 = 0 ;
46802 int res2 = 0 ;
46803 PyObject * obj0 = 0 ;
46804 PyObject * obj1 = 0 ;
46805 char * kwnames[] = {
46806 (char *) "self",(char *) "window", NULL
46807 };
46808
46809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46811 if (!SWIG_IsOK(res1)) {
46812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46813 }
46814 arg1 = reinterpret_cast< wxSizer * >(argp1);
46815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46816 if (!SWIG_IsOK(res2)) {
46817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46818 }
46819 arg2 = reinterpret_cast< wxWindow * >(argp2);
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 (arg1)->FitInside(arg2);
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_Py_Void();
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46834 PyObject *resultobj = 0;
46835 wxSizer *arg1 = (wxSizer *) 0 ;
46836 wxWindow *arg2 = (wxWindow *) 0 ;
46837 void *argp1 = 0 ;
46838 int res1 = 0 ;
46839 void *argp2 = 0 ;
46840 int res2 = 0 ;
46841 PyObject * obj0 = 0 ;
46842 PyObject * obj1 = 0 ;
46843 char * kwnames[] = {
46844 (char *) "self",(char *) "window", NULL
46845 };
46846
46847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizer * >(argp1);
46853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46854 if (!SWIG_IsOK(res2)) {
46855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46856 }
46857 arg2 = reinterpret_cast< wxWindow * >(argp2);
46858 {
46859 PyThreadState* __tstate = wxPyBeginAllowThreads();
46860 (arg1)->SetSizeHints(arg2);
46861 wxPyEndAllowThreads(__tstate);
46862 if (PyErr_Occurred()) SWIG_fail;
46863 }
46864 resultobj = SWIG_Py_Void();
46865 return resultobj;
46866 fail:
46867 return NULL;
46868 }
46869
46870
46871 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46872 PyObject *resultobj = 0;
46873 wxSizer *arg1 = (wxSizer *) 0 ;
46874 wxWindow *arg2 = (wxWindow *) 0 ;
46875 void *argp1 = 0 ;
46876 int res1 = 0 ;
46877 void *argp2 = 0 ;
46878 int res2 = 0 ;
46879 PyObject * obj0 = 0 ;
46880 PyObject * obj1 = 0 ;
46881 char * kwnames[] = {
46882 (char *) "self",(char *) "window", NULL
46883 };
46884
46885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46887 if (!SWIG_IsOK(res1)) {
46888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46889 }
46890 arg1 = reinterpret_cast< wxSizer * >(argp1);
46891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46892 if (!SWIG_IsOK(res2)) {
46893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46894 }
46895 arg2 = reinterpret_cast< wxWindow * >(argp2);
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 (arg1)->SetVirtualSizeHints(arg2);
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 resultobj = SWIG_Py_Void();
46903 return resultobj;
46904 fail:
46905 return NULL;
46906 }
46907
46908
46909 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46910 PyObject *resultobj = 0;
46911 wxSizer *arg1 = (wxSizer *) 0 ;
46912 bool arg2 = (bool) false ;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 bool val2 ;
46916 int ecode2 = 0 ;
46917 PyObject * obj0 = 0 ;
46918 PyObject * obj1 = 0 ;
46919 char * kwnames[] = {
46920 (char *) "self",(char *) "deleteWindows", NULL
46921 };
46922
46923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46925 if (!SWIG_IsOK(res1)) {
46926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46927 }
46928 arg1 = reinterpret_cast< wxSizer * >(argp1);
46929 if (obj1) {
46930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46931 if (!SWIG_IsOK(ecode2)) {
46932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46933 }
46934 arg2 = static_cast< bool >(val2);
46935 }
46936 {
46937 PyThreadState* __tstate = wxPyBeginAllowThreads();
46938 (arg1)->Clear(arg2);
46939 wxPyEndAllowThreads(__tstate);
46940 if (PyErr_Occurred()) SWIG_fail;
46941 }
46942 resultobj = SWIG_Py_Void();
46943 return resultobj;
46944 fail:
46945 return NULL;
46946 }
46947
46948
46949 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46950 PyObject *resultobj = 0;
46951 wxSizer *arg1 = (wxSizer *) 0 ;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 PyObject *swig_obj[1] ;
46955
46956 if (!args) SWIG_fail;
46957 swig_obj[0] = args;
46958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46959 if (!SWIG_IsOK(res1)) {
46960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46961 }
46962 arg1 = reinterpret_cast< wxSizer * >(argp1);
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 (arg1)->DeleteWindows();
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 resultobj = SWIG_Py_Void();
46970 return resultobj;
46971 fail:
46972 return NULL;
46973 }
46974
46975
46976 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46977 PyObject *resultobj = 0;
46978 wxSizer *arg1 = (wxSizer *) 0 ;
46979 PyObject *result = 0 ;
46980 void *argp1 = 0 ;
46981 int res1 = 0 ;
46982 PyObject *swig_obj[1] ;
46983
46984 if (!args) SWIG_fail;
46985 swig_obj[0] = args;
46986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46987 if (!SWIG_IsOK(res1)) {
46988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46989 }
46990 arg1 = reinterpret_cast< wxSizer * >(argp1);
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 result = (PyObject *)wxSizer_GetChildren(arg1);
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 resultobj = result;
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 PyObject *arg2 = (PyObject *) 0 ;
47008 bool arg3 = (bool) true ;
47009 bool arg4 = (bool) false ;
47010 bool result;
47011 void *argp1 = 0 ;
47012 int res1 = 0 ;
47013 bool val3 ;
47014 int ecode3 = 0 ;
47015 bool val4 ;
47016 int ecode4 = 0 ;
47017 PyObject * obj0 = 0 ;
47018 PyObject * obj1 = 0 ;
47019 PyObject * obj2 = 0 ;
47020 PyObject * obj3 = 0 ;
47021 char * kwnames[] = {
47022 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47023 };
47024
47025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47027 if (!SWIG_IsOK(res1)) {
47028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47029 }
47030 arg1 = reinterpret_cast< wxSizer * >(argp1);
47031 arg2 = obj1;
47032 if (obj2) {
47033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47034 if (!SWIG_IsOK(ecode3)) {
47035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47036 }
47037 arg3 = static_cast< bool >(val3);
47038 }
47039 if (obj3) {
47040 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47041 if (!SWIG_IsOK(ecode4)) {
47042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47043 }
47044 arg4 = static_cast< bool >(val4);
47045 }
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47049 wxPyEndAllowThreads(__tstate);
47050 if (PyErr_Occurred()) SWIG_fail;
47051 }
47052 {
47053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47054 }
47055 return resultobj;
47056 fail:
47057 return NULL;
47058 }
47059
47060
47061 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47062 PyObject *resultobj = 0;
47063 wxSizer *arg1 = (wxSizer *) 0 ;
47064 PyObject *arg2 = (PyObject *) 0 ;
47065 bool result;
47066 void *argp1 = 0 ;
47067 int res1 = 0 ;
47068 PyObject * obj0 = 0 ;
47069 PyObject * obj1 = 0 ;
47070 char * kwnames[] = {
47071 (char *) "self",(char *) "item", NULL
47072 };
47073
47074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizer * >(argp1);
47080 arg2 = obj1;
47081 {
47082 PyThreadState* __tstate = wxPyBeginAllowThreads();
47083 result = (bool)wxSizer_IsShown(arg1,arg2);
47084 wxPyEndAllowThreads(__tstate);
47085 if (PyErr_Occurred()) SWIG_fail;
47086 }
47087 {
47088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47089 }
47090 return resultobj;
47091 fail:
47092 return NULL;
47093 }
47094
47095
47096 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47097 PyObject *resultobj = 0;
47098 wxSizer *arg1 = (wxSizer *) 0 ;
47099 bool arg2 ;
47100 void *argp1 = 0 ;
47101 int res1 = 0 ;
47102 bool val2 ;
47103 int ecode2 = 0 ;
47104 PyObject * obj0 = 0 ;
47105 PyObject * obj1 = 0 ;
47106 char * kwnames[] = {
47107 (char *) "self",(char *) "show", NULL
47108 };
47109
47110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47112 if (!SWIG_IsOK(res1)) {
47113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47114 }
47115 arg1 = reinterpret_cast< wxSizer * >(argp1);
47116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47117 if (!SWIG_IsOK(ecode2)) {
47118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47119 }
47120 arg2 = static_cast< bool >(val2);
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 (arg1)->ShowItems(arg2);
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_Py_Void();
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 PyObject *obj;
47136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47137 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47138 return SWIG_Py_Void();
47139 }
47140
47141 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47142 PyObject *resultobj = 0;
47143 wxPySizer *result = 0 ;
47144
47145 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 result = (wxPySizer *)new wxPySizer();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47160 PyObject *resultobj = 0;
47161 wxPySizer *arg1 = (wxPySizer *) 0 ;
47162 PyObject *arg2 = (PyObject *) 0 ;
47163 PyObject *arg3 = (PyObject *) 0 ;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 PyObject * obj0 = 0 ;
47167 PyObject * obj1 = 0 ;
47168 PyObject * obj2 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "self",(char *) "_class", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47177 }
47178 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47179 arg2 = obj1;
47180 arg3 = obj2;
47181 {
47182 PyThreadState* __tstate = wxPyBeginAllowThreads();
47183 (arg1)->_setCallbackInfo(arg2,arg3);
47184 wxPyEndAllowThreads(__tstate);
47185 if (PyErr_Occurred()) SWIG_fail;
47186 }
47187 resultobj = SWIG_Py_Void();
47188 return resultobj;
47189 fail:
47190 return NULL;
47191 }
47192
47193
47194 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47195 PyObject *obj;
47196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47197 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47198 return SWIG_Py_Void();
47199 }
47200
47201 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47202 return SWIG_Python_InitShadowInstance(args);
47203 }
47204
47205 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47206 PyObject *resultobj = 0;
47207 int arg1 = (int) wxHORIZONTAL ;
47208 wxBoxSizer *result = 0 ;
47209 int val1 ;
47210 int ecode1 = 0 ;
47211 PyObject * obj0 = 0 ;
47212 char * kwnames[] = {
47213 (char *) "orient", NULL
47214 };
47215
47216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47217 if (obj0) {
47218 ecode1 = SWIG_AsVal_int(obj0, &val1);
47219 if (!SWIG_IsOK(ecode1)) {
47220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47221 }
47222 arg1 = static_cast< int >(val1);
47223 }
47224 {
47225 PyThreadState* __tstate = wxPyBeginAllowThreads();
47226 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47227 wxPyEndAllowThreads(__tstate);
47228 if (PyErr_Occurred()) SWIG_fail;
47229 }
47230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47231 return resultobj;
47232 fail:
47233 return NULL;
47234 }
47235
47236
47237 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47238 PyObject *resultobj = 0;
47239 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47240 int result;
47241 void *argp1 = 0 ;
47242 int res1 = 0 ;
47243 PyObject *swig_obj[1] ;
47244
47245 if (!args) SWIG_fail;
47246 swig_obj[0] = args;
47247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47248 if (!SWIG_IsOK(res1)) {
47249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47250 }
47251 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 result = (int)(arg1)->GetOrientation();
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 resultobj = SWIG_From_int(static_cast< int >(result));
47259 return resultobj;
47260 fail:
47261 return NULL;
47262 }
47263
47264
47265 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47266 PyObject *resultobj = 0;
47267 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47268 int arg2 ;
47269 void *argp1 = 0 ;
47270 int res1 = 0 ;
47271 int val2 ;
47272 int ecode2 = 0 ;
47273 PyObject * obj0 = 0 ;
47274 PyObject * obj1 = 0 ;
47275 char * kwnames[] = {
47276 (char *) "self",(char *) "orient", NULL
47277 };
47278
47279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47281 if (!SWIG_IsOK(res1)) {
47282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47283 }
47284 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47285 ecode2 = SWIG_AsVal_int(obj1, &val2);
47286 if (!SWIG_IsOK(ecode2)) {
47287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47288 }
47289 arg2 = static_cast< int >(val2);
47290 {
47291 PyThreadState* __tstate = wxPyBeginAllowThreads();
47292 (arg1)->SetOrientation(arg2);
47293 wxPyEndAllowThreads(__tstate);
47294 if (PyErr_Occurred()) SWIG_fail;
47295 }
47296 resultobj = SWIG_Py_Void();
47297 return resultobj;
47298 fail:
47299 return NULL;
47300 }
47301
47302
47303 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47304 PyObject *obj;
47305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47306 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47307 return SWIG_Py_Void();
47308 }
47309
47310 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47311 return SWIG_Python_InitShadowInstance(args);
47312 }
47313
47314 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47315 PyObject *resultobj = 0;
47316 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47317 int arg2 = (int) wxHORIZONTAL ;
47318 wxStaticBoxSizer *result = 0 ;
47319 void *argp1 = 0 ;
47320 int res1 = 0 ;
47321 int val2 ;
47322 int ecode2 = 0 ;
47323 PyObject * obj0 = 0 ;
47324 PyObject * obj1 = 0 ;
47325 char * kwnames[] = {
47326 (char *) "box",(char *) "orient", NULL
47327 };
47328
47329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47331 if (!SWIG_IsOK(res1)) {
47332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47333 }
47334 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47335 if (obj1) {
47336 ecode2 = SWIG_AsVal_int(obj1, &val2);
47337 if (!SWIG_IsOK(ecode2)) {
47338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47339 }
47340 arg2 = static_cast< int >(val2);
47341 }
47342 {
47343 PyThreadState* __tstate = wxPyBeginAllowThreads();
47344 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47345 wxPyEndAllowThreads(__tstate);
47346 if (PyErr_Occurred()) SWIG_fail;
47347 }
47348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47349 return resultobj;
47350 fail:
47351 return NULL;
47352 }
47353
47354
47355 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47356 PyObject *resultobj = 0;
47357 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47358 wxStaticBox *result = 0 ;
47359 void *argp1 = 0 ;
47360 int res1 = 0 ;
47361 PyObject *swig_obj[1] ;
47362
47363 if (!args) SWIG_fail;
47364 swig_obj[0] = args;
47365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47366 if (!SWIG_IsOK(res1)) {
47367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47368 }
47369 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 result = (wxStaticBox *)(arg1)->GetStaticBox();
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 {
47377 resultobj = wxPyMake_wxObject(result, (bool)0);
47378 }
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47386 PyObject *obj;
47387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47388 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47389 return SWIG_Py_Void();
47390 }
47391
47392 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47393 return SWIG_Python_InitShadowInstance(args);
47394 }
47395
47396 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47397 PyObject *resultobj = 0;
47398 int arg1 = (int) 1 ;
47399 int arg2 = (int) 0 ;
47400 int arg3 = (int) 0 ;
47401 int arg4 = (int) 0 ;
47402 wxGridSizer *result = 0 ;
47403 int val1 ;
47404 int ecode1 = 0 ;
47405 int val2 ;
47406 int ecode2 = 0 ;
47407 int val3 ;
47408 int ecode3 = 0 ;
47409 int val4 ;
47410 int ecode4 = 0 ;
47411 PyObject * obj0 = 0 ;
47412 PyObject * obj1 = 0 ;
47413 PyObject * obj2 = 0 ;
47414 PyObject * obj3 = 0 ;
47415 char * kwnames[] = {
47416 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47417 };
47418
47419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47420 if (obj0) {
47421 ecode1 = SWIG_AsVal_int(obj0, &val1);
47422 if (!SWIG_IsOK(ecode1)) {
47423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47424 }
47425 arg1 = static_cast< int >(val1);
47426 }
47427 if (obj1) {
47428 ecode2 = SWIG_AsVal_int(obj1, &val2);
47429 if (!SWIG_IsOK(ecode2)) {
47430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47431 }
47432 arg2 = static_cast< int >(val2);
47433 }
47434 if (obj2) {
47435 ecode3 = SWIG_AsVal_int(obj2, &val3);
47436 if (!SWIG_IsOK(ecode3)) {
47437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47438 }
47439 arg3 = static_cast< int >(val3);
47440 }
47441 if (obj3) {
47442 ecode4 = SWIG_AsVal_int(obj3, &val4);
47443 if (!SWIG_IsOK(ecode4)) {
47444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47445 }
47446 arg4 = static_cast< int >(val4);
47447 }
47448 {
47449 PyThreadState* __tstate = wxPyBeginAllowThreads();
47450 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47451 wxPyEndAllowThreads(__tstate);
47452 if (PyErr_Occurred()) SWIG_fail;
47453 }
47454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47455 return resultobj;
47456 fail:
47457 return NULL;
47458 }
47459
47460
47461 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47462 PyObject *resultobj = 0;
47463 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47464 int arg2 ;
47465 void *argp1 = 0 ;
47466 int res1 = 0 ;
47467 int val2 ;
47468 int ecode2 = 0 ;
47469 PyObject * obj0 = 0 ;
47470 PyObject * obj1 = 0 ;
47471 char * kwnames[] = {
47472 (char *) "self",(char *) "cols", NULL
47473 };
47474
47475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47477 if (!SWIG_IsOK(res1)) {
47478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47479 }
47480 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47481 ecode2 = SWIG_AsVal_int(obj1, &val2);
47482 if (!SWIG_IsOK(ecode2)) {
47483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47484 }
47485 arg2 = static_cast< int >(val2);
47486 {
47487 PyThreadState* __tstate = wxPyBeginAllowThreads();
47488 (arg1)->SetCols(arg2);
47489 wxPyEndAllowThreads(__tstate);
47490 if (PyErr_Occurred()) SWIG_fail;
47491 }
47492 resultobj = SWIG_Py_Void();
47493 return resultobj;
47494 fail:
47495 return NULL;
47496 }
47497
47498
47499 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47500 PyObject *resultobj = 0;
47501 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47502 int arg2 ;
47503 void *argp1 = 0 ;
47504 int res1 = 0 ;
47505 int val2 ;
47506 int ecode2 = 0 ;
47507 PyObject * obj0 = 0 ;
47508 PyObject * obj1 = 0 ;
47509 char * kwnames[] = {
47510 (char *) "self",(char *) "rows", NULL
47511 };
47512
47513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47515 if (!SWIG_IsOK(res1)) {
47516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47517 }
47518 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47519 ecode2 = SWIG_AsVal_int(obj1, &val2);
47520 if (!SWIG_IsOK(ecode2)) {
47521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47522 }
47523 arg2 = static_cast< int >(val2);
47524 {
47525 PyThreadState* __tstate = wxPyBeginAllowThreads();
47526 (arg1)->SetRows(arg2);
47527 wxPyEndAllowThreads(__tstate);
47528 if (PyErr_Occurred()) SWIG_fail;
47529 }
47530 resultobj = SWIG_Py_Void();
47531 return resultobj;
47532 fail:
47533 return NULL;
47534 }
47535
47536
47537 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47538 PyObject *resultobj = 0;
47539 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47540 int arg2 ;
47541 void *argp1 = 0 ;
47542 int res1 = 0 ;
47543 int val2 ;
47544 int ecode2 = 0 ;
47545 PyObject * obj0 = 0 ;
47546 PyObject * obj1 = 0 ;
47547 char * kwnames[] = {
47548 (char *) "self",(char *) "gap", NULL
47549 };
47550
47551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47553 if (!SWIG_IsOK(res1)) {
47554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47555 }
47556 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47557 ecode2 = SWIG_AsVal_int(obj1, &val2);
47558 if (!SWIG_IsOK(ecode2)) {
47559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47560 }
47561 arg2 = static_cast< int >(val2);
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 (arg1)->SetVGap(arg2);
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = SWIG_Py_Void();
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47576 PyObject *resultobj = 0;
47577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47578 int arg2 ;
47579 void *argp1 = 0 ;
47580 int res1 = 0 ;
47581 int val2 ;
47582 int ecode2 = 0 ;
47583 PyObject * obj0 = 0 ;
47584 PyObject * obj1 = 0 ;
47585 char * kwnames[] = {
47586 (char *) "self",(char *) "gap", NULL
47587 };
47588
47589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47591 if (!SWIG_IsOK(res1)) {
47592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47593 }
47594 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47595 ecode2 = SWIG_AsVal_int(obj1, &val2);
47596 if (!SWIG_IsOK(ecode2)) {
47597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47598 }
47599 arg2 = static_cast< int >(val2);
47600 {
47601 PyThreadState* __tstate = wxPyBeginAllowThreads();
47602 (arg1)->SetHGap(arg2);
47603 wxPyEndAllowThreads(__tstate);
47604 if (PyErr_Occurred()) SWIG_fail;
47605 }
47606 resultobj = SWIG_Py_Void();
47607 return resultobj;
47608 fail:
47609 return NULL;
47610 }
47611
47612
47613 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47614 PyObject *resultobj = 0;
47615 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47616 int result;
47617 void *argp1 = 0 ;
47618 int res1 = 0 ;
47619 PyObject *swig_obj[1] ;
47620
47621 if (!args) SWIG_fail;
47622 swig_obj[0] = args;
47623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47624 if (!SWIG_IsOK(res1)) {
47625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47626 }
47627 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47628 {
47629 PyThreadState* __tstate = wxPyBeginAllowThreads();
47630 result = (int)(arg1)->GetCols();
47631 wxPyEndAllowThreads(__tstate);
47632 if (PyErr_Occurred()) SWIG_fail;
47633 }
47634 resultobj = SWIG_From_int(static_cast< int >(result));
47635 return resultobj;
47636 fail:
47637 return NULL;
47638 }
47639
47640
47641 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47642 PyObject *resultobj = 0;
47643 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47644 int result;
47645 void *argp1 = 0 ;
47646 int res1 = 0 ;
47647 PyObject *swig_obj[1] ;
47648
47649 if (!args) SWIG_fail;
47650 swig_obj[0] = args;
47651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47652 if (!SWIG_IsOK(res1)) {
47653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47654 }
47655 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 result = (int)(arg1)->GetRows();
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_From_int(static_cast< int >(result));
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47670 PyObject *resultobj = 0;
47671 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47672 int result;
47673 void *argp1 = 0 ;
47674 int res1 = 0 ;
47675 PyObject *swig_obj[1] ;
47676
47677 if (!args) SWIG_fail;
47678 swig_obj[0] = args;
47679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47680 if (!SWIG_IsOK(res1)) {
47681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47682 }
47683 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47684 {
47685 PyThreadState* __tstate = wxPyBeginAllowThreads();
47686 result = (int)(arg1)->GetVGap();
47687 wxPyEndAllowThreads(__tstate);
47688 if (PyErr_Occurred()) SWIG_fail;
47689 }
47690 resultobj = SWIG_From_int(static_cast< int >(result));
47691 return resultobj;
47692 fail:
47693 return NULL;
47694 }
47695
47696
47697 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47698 PyObject *resultobj = 0;
47699 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47700 int result;
47701 void *argp1 = 0 ;
47702 int res1 = 0 ;
47703 PyObject *swig_obj[1] ;
47704
47705 if (!args) SWIG_fail;
47706 swig_obj[0] = args;
47707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47708 if (!SWIG_IsOK(res1)) {
47709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47710 }
47711 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47712 {
47713 PyThreadState* __tstate = wxPyBeginAllowThreads();
47714 result = (int)(arg1)->GetHGap();
47715 wxPyEndAllowThreads(__tstate);
47716 if (PyErr_Occurred()) SWIG_fail;
47717 }
47718 resultobj = SWIG_From_int(static_cast< int >(result));
47719 return resultobj;
47720 fail:
47721 return NULL;
47722 }
47723
47724
47725 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47726 PyObject *obj;
47727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47728 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47729 return SWIG_Py_Void();
47730 }
47731
47732 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47733 return SWIG_Python_InitShadowInstance(args);
47734 }
47735
47736 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47737 PyObject *resultobj = 0;
47738 int arg1 = (int) 1 ;
47739 int arg2 = (int) 0 ;
47740 int arg3 = (int) 0 ;
47741 int arg4 = (int) 0 ;
47742 wxFlexGridSizer *result = 0 ;
47743 int val1 ;
47744 int ecode1 = 0 ;
47745 int val2 ;
47746 int ecode2 = 0 ;
47747 int val3 ;
47748 int ecode3 = 0 ;
47749 int val4 ;
47750 int ecode4 = 0 ;
47751 PyObject * obj0 = 0 ;
47752 PyObject * obj1 = 0 ;
47753 PyObject * obj2 = 0 ;
47754 PyObject * obj3 = 0 ;
47755 char * kwnames[] = {
47756 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47757 };
47758
47759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47760 if (obj0) {
47761 ecode1 = SWIG_AsVal_int(obj0, &val1);
47762 if (!SWIG_IsOK(ecode1)) {
47763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47764 }
47765 arg1 = static_cast< int >(val1);
47766 }
47767 if (obj1) {
47768 ecode2 = SWIG_AsVal_int(obj1, &val2);
47769 if (!SWIG_IsOK(ecode2)) {
47770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47771 }
47772 arg2 = static_cast< int >(val2);
47773 }
47774 if (obj2) {
47775 ecode3 = SWIG_AsVal_int(obj2, &val3);
47776 if (!SWIG_IsOK(ecode3)) {
47777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47778 }
47779 arg3 = static_cast< int >(val3);
47780 }
47781 if (obj3) {
47782 ecode4 = SWIG_AsVal_int(obj3, &val4);
47783 if (!SWIG_IsOK(ecode4)) {
47784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47785 }
47786 arg4 = static_cast< int >(val4);
47787 }
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47802 PyObject *resultobj = 0;
47803 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47804 size_t arg2 ;
47805 int arg3 = (int) 0 ;
47806 void *argp1 = 0 ;
47807 int res1 = 0 ;
47808 size_t val2 ;
47809 int ecode2 = 0 ;
47810 int val3 ;
47811 int ecode3 = 0 ;
47812 PyObject * obj0 = 0 ;
47813 PyObject * obj1 = 0 ;
47814 PyObject * obj2 = 0 ;
47815 char * kwnames[] = {
47816 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47817 };
47818
47819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47821 if (!SWIG_IsOK(res1)) {
47822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47823 }
47824 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47825 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47826 if (!SWIG_IsOK(ecode2)) {
47827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47828 }
47829 arg2 = static_cast< size_t >(val2);
47830 if (obj2) {
47831 ecode3 = SWIG_AsVal_int(obj2, &val3);
47832 if (!SWIG_IsOK(ecode3)) {
47833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47834 }
47835 arg3 = static_cast< int >(val3);
47836 }
47837 {
47838 PyThreadState* __tstate = wxPyBeginAllowThreads();
47839 (arg1)->AddGrowableRow(arg2,arg3);
47840 wxPyEndAllowThreads(__tstate);
47841 if (PyErr_Occurred()) SWIG_fail;
47842 }
47843 resultobj = SWIG_Py_Void();
47844 return resultobj;
47845 fail:
47846 return NULL;
47847 }
47848
47849
47850 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47851 PyObject *resultobj = 0;
47852 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47853 size_t arg2 ;
47854 void *argp1 = 0 ;
47855 int res1 = 0 ;
47856 size_t val2 ;
47857 int ecode2 = 0 ;
47858 PyObject * obj0 = 0 ;
47859 PyObject * obj1 = 0 ;
47860 char * kwnames[] = {
47861 (char *) "self",(char *) "idx", NULL
47862 };
47863
47864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47866 if (!SWIG_IsOK(res1)) {
47867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47868 }
47869 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47870 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47871 if (!SWIG_IsOK(ecode2)) {
47872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47873 }
47874 arg2 = static_cast< size_t >(val2);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 (arg1)->RemoveGrowableRow(arg2);
47878 wxPyEndAllowThreads(__tstate);
47879 if (PyErr_Occurred()) SWIG_fail;
47880 }
47881 resultobj = SWIG_Py_Void();
47882 return resultobj;
47883 fail:
47884 return NULL;
47885 }
47886
47887
47888 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47889 PyObject *resultobj = 0;
47890 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47891 size_t arg2 ;
47892 int arg3 = (int) 0 ;
47893 void *argp1 = 0 ;
47894 int res1 = 0 ;
47895 size_t val2 ;
47896 int ecode2 = 0 ;
47897 int val3 ;
47898 int ecode3 = 0 ;
47899 PyObject * obj0 = 0 ;
47900 PyObject * obj1 = 0 ;
47901 PyObject * obj2 = 0 ;
47902 char * kwnames[] = {
47903 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47904 };
47905
47906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47908 if (!SWIG_IsOK(res1)) {
47909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47910 }
47911 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47913 if (!SWIG_IsOK(ecode2)) {
47914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47915 }
47916 arg2 = static_cast< size_t >(val2);
47917 if (obj2) {
47918 ecode3 = SWIG_AsVal_int(obj2, &val3);
47919 if (!SWIG_IsOK(ecode3)) {
47920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47921 }
47922 arg3 = static_cast< int >(val3);
47923 }
47924 {
47925 PyThreadState* __tstate = wxPyBeginAllowThreads();
47926 (arg1)->AddGrowableCol(arg2,arg3);
47927 wxPyEndAllowThreads(__tstate);
47928 if (PyErr_Occurred()) SWIG_fail;
47929 }
47930 resultobj = SWIG_Py_Void();
47931 return resultobj;
47932 fail:
47933 return NULL;
47934 }
47935
47936
47937 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47938 PyObject *resultobj = 0;
47939 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47940 size_t arg2 ;
47941 void *argp1 = 0 ;
47942 int res1 = 0 ;
47943 size_t val2 ;
47944 int ecode2 = 0 ;
47945 PyObject * obj0 = 0 ;
47946 PyObject * obj1 = 0 ;
47947 char * kwnames[] = {
47948 (char *) "self",(char *) "idx", NULL
47949 };
47950
47951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47953 if (!SWIG_IsOK(res1)) {
47954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47955 }
47956 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47957 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47958 if (!SWIG_IsOK(ecode2)) {
47959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47960 }
47961 arg2 = static_cast< size_t >(val2);
47962 {
47963 PyThreadState* __tstate = wxPyBeginAllowThreads();
47964 (arg1)->RemoveGrowableCol(arg2);
47965 wxPyEndAllowThreads(__tstate);
47966 if (PyErr_Occurred()) SWIG_fail;
47967 }
47968 resultobj = SWIG_Py_Void();
47969 return resultobj;
47970 fail:
47971 return NULL;
47972 }
47973
47974
47975 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47976 PyObject *resultobj = 0;
47977 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47978 int arg2 ;
47979 void *argp1 = 0 ;
47980 int res1 = 0 ;
47981 int val2 ;
47982 int ecode2 = 0 ;
47983 PyObject * obj0 = 0 ;
47984 PyObject * obj1 = 0 ;
47985 char * kwnames[] = {
47986 (char *) "self",(char *) "direction", NULL
47987 };
47988
47989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47991 if (!SWIG_IsOK(res1)) {
47992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47993 }
47994 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47995 ecode2 = SWIG_AsVal_int(obj1, &val2);
47996 if (!SWIG_IsOK(ecode2)) {
47997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47998 }
47999 arg2 = static_cast< int >(val2);
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 (arg1)->SetFlexibleDirection(arg2);
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 resultobj = SWIG_Py_Void();
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48014 PyObject *resultobj = 0;
48015 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48016 int result;
48017 void *argp1 = 0 ;
48018 int res1 = 0 ;
48019 PyObject *swig_obj[1] ;
48020
48021 if (!args) SWIG_fail;
48022 swig_obj[0] = args;
48023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48024 if (!SWIG_IsOK(res1)) {
48025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48026 }
48027 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48028 {
48029 PyThreadState* __tstate = wxPyBeginAllowThreads();
48030 result = (int)(arg1)->GetFlexibleDirection();
48031 wxPyEndAllowThreads(__tstate);
48032 if (PyErr_Occurred()) SWIG_fail;
48033 }
48034 resultobj = SWIG_From_int(static_cast< int >(result));
48035 return resultobj;
48036 fail:
48037 return NULL;
48038 }
48039
48040
48041 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48042 PyObject *resultobj = 0;
48043 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48044 wxFlexSizerGrowMode arg2 ;
48045 void *argp1 = 0 ;
48046 int res1 = 0 ;
48047 int val2 ;
48048 int ecode2 = 0 ;
48049 PyObject * obj0 = 0 ;
48050 PyObject * obj1 = 0 ;
48051 char * kwnames[] = {
48052 (char *) "self",(char *) "mode", NULL
48053 };
48054
48055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48057 if (!SWIG_IsOK(res1)) {
48058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48059 }
48060 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48061 ecode2 = SWIG_AsVal_int(obj1, &val2);
48062 if (!SWIG_IsOK(ecode2)) {
48063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48064 }
48065 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48066 {
48067 PyThreadState* __tstate = wxPyBeginAllowThreads();
48068 (arg1)->SetNonFlexibleGrowMode(arg2);
48069 wxPyEndAllowThreads(__tstate);
48070 if (PyErr_Occurred()) SWIG_fail;
48071 }
48072 resultobj = SWIG_Py_Void();
48073 return resultobj;
48074 fail:
48075 return NULL;
48076 }
48077
48078
48079 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48080 PyObject *resultobj = 0;
48081 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48082 wxFlexSizerGrowMode result;
48083 void *argp1 = 0 ;
48084 int res1 = 0 ;
48085 PyObject *swig_obj[1] ;
48086
48087 if (!args) SWIG_fail;
48088 swig_obj[0] = args;
48089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48090 if (!SWIG_IsOK(res1)) {
48091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48092 }
48093 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_From_int(static_cast< int >(result));
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48108 PyObject *resultobj = 0;
48109 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48110 wxArrayInt *result = 0 ;
48111 void *argp1 = 0 ;
48112 int res1 = 0 ;
48113 PyObject *swig_obj[1] ;
48114
48115 if (!args) SWIG_fail;
48116 swig_obj[0] = args;
48117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48118 if (!SWIG_IsOK(res1)) {
48119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48120 }
48121 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48122 {
48123 PyThreadState* __tstate = wxPyBeginAllowThreads();
48124 {
48125 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48126 result = (wxArrayInt *) &_result_ref;
48127 }
48128 wxPyEndAllowThreads(__tstate);
48129 if (PyErr_Occurred()) SWIG_fail;
48130 }
48131 {
48132 resultobj = PyList_New(0);
48133 size_t idx;
48134 for (idx = 0; idx < result->GetCount(); idx += 1) {
48135 PyObject* val = PyInt_FromLong( result->Item(idx) );
48136 PyList_Append(resultobj, val);
48137 Py_DECREF(val);
48138 }
48139 }
48140 return resultobj;
48141 fail:
48142 return NULL;
48143 }
48144
48145
48146 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48147 PyObject *resultobj = 0;
48148 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48149 wxArrayInt *result = 0 ;
48150 void *argp1 = 0 ;
48151 int res1 = 0 ;
48152 PyObject *swig_obj[1] ;
48153
48154 if (!args) SWIG_fail;
48155 swig_obj[0] = args;
48156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48157 if (!SWIG_IsOK(res1)) {
48158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48159 }
48160 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48161 {
48162 PyThreadState* __tstate = wxPyBeginAllowThreads();
48163 {
48164 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48165 result = (wxArrayInt *) &_result_ref;
48166 }
48167 wxPyEndAllowThreads(__tstate);
48168 if (PyErr_Occurred()) SWIG_fail;
48169 }
48170 {
48171 resultobj = PyList_New(0);
48172 size_t idx;
48173 for (idx = 0; idx < result->GetCount(); idx += 1) {
48174 PyObject* val = PyInt_FromLong( result->Item(idx) );
48175 PyList_Append(resultobj, val);
48176 Py_DECREF(val);
48177 }
48178 }
48179 return resultobj;
48180 fail:
48181 return NULL;
48182 }
48183
48184
48185 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48186 PyObject *obj;
48187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48188 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48189 return SWIG_Py_Void();
48190 }
48191
48192 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48193 return SWIG_Python_InitShadowInstance(args);
48194 }
48195
48196 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48197 PyObject *resultobj = 0;
48198 wxStdDialogButtonSizer *result = 0 ;
48199
48200 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48217 wxButton *arg2 = (wxButton *) 0 ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 void *argp2 = 0 ;
48221 int res2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "button", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48235 if (!SWIG_IsOK(res2)) {
48236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48237 }
48238 arg2 = reinterpret_cast< wxButton * >(argp2);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->AddButton(arg2);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48253 PyObject *resultobj = 0;
48254 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48255 void *argp1 = 0 ;
48256 int res1 = 0 ;
48257 PyObject *swig_obj[1] ;
48258
48259 if (!args) SWIG_fail;
48260 swig_obj[0] = args;
48261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48262 if (!SWIG_IsOK(res1)) {
48263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48264 }
48265 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48266 {
48267 PyThreadState* __tstate = wxPyBeginAllowThreads();
48268 (arg1)->Realize();
48269 wxPyEndAllowThreads(__tstate);
48270 if (PyErr_Occurred()) SWIG_fail;
48271 }
48272 resultobj = SWIG_Py_Void();
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48280 PyObject *resultobj = 0;
48281 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48282 wxButton *arg2 = (wxButton *) 0 ;
48283 void *argp1 = 0 ;
48284 int res1 = 0 ;
48285 void *argp2 = 0 ;
48286 int res2 = 0 ;
48287 PyObject * obj0 = 0 ;
48288 PyObject * obj1 = 0 ;
48289 char * kwnames[] = {
48290 (char *) "self",(char *) "button", NULL
48291 };
48292
48293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48295 if (!SWIG_IsOK(res1)) {
48296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48297 }
48298 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48300 if (!SWIG_IsOK(res2)) {
48301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48302 }
48303 arg2 = reinterpret_cast< wxButton * >(argp2);
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 (arg1)->SetAffirmativeButton(arg2);
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 resultobj = SWIG_Py_Void();
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48318 PyObject *resultobj = 0;
48319 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48320 wxButton *arg2 = (wxButton *) 0 ;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 void *argp2 = 0 ;
48324 int res2 = 0 ;
48325 PyObject * obj0 = 0 ;
48326 PyObject * obj1 = 0 ;
48327 char * kwnames[] = {
48328 (char *) "self",(char *) "button", NULL
48329 };
48330
48331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48333 if (!SWIG_IsOK(res1)) {
48334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48335 }
48336 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48338 if (!SWIG_IsOK(res2)) {
48339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48340 }
48341 arg2 = reinterpret_cast< wxButton * >(argp2);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 (arg1)->SetNegativeButton(arg2);
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 resultobj = SWIG_Py_Void();
48349 return resultobj;
48350 fail:
48351 return NULL;
48352 }
48353
48354
48355 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48356 PyObject *resultobj = 0;
48357 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48358 wxButton *arg2 = (wxButton *) 0 ;
48359 void *argp1 = 0 ;
48360 int res1 = 0 ;
48361 void *argp2 = 0 ;
48362 int res2 = 0 ;
48363 PyObject * obj0 = 0 ;
48364 PyObject * obj1 = 0 ;
48365 char * kwnames[] = {
48366 (char *) "self",(char *) "button", NULL
48367 };
48368
48369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48371 if (!SWIG_IsOK(res1)) {
48372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48373 }
48374 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48376 if (!SWIG_IsOK(res2)) {
48377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48378 }
48379 arg2 = reinterpret_cast< wxButton * >(argp2);
48380 {
48381 PyThreadState* __tstate = wxPyBeginAllowThreads();
48382 (arg1)->SetCancelButton(arg2);
48383 wxPyEndAllowThreads(__tstate);
48384 if (PyErr_Occurred()) SWIG_fail;
48385 }
48386 resultobj = SWIG_Py_Void();
48387 return resultobj;
48388 fail:
48389 return NULL;
48390 }
48391
48392
48393 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48394 PyObject *resultobj = 0;
48395 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48396 wxButton *result = 0 ;
48397 void *argp1 = 0 ;
48398 int res1 = 0 ;
48399 PyObject *swig_obj[1] ;
48400
48401 if (!args) SWIG_fail;
48402 swig_obj[0] = args;
48403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48404 if (!SWIG_IsOK(res1)) {
48405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48406 }
48407 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48411 wxPyEndAllowThreads(__tstate);
48412 if (PyErr_Occurred()) SWIG_fail;
48413 }
48414 {
48415 resultobj = wxPyMake_wxObject(result, (bool)0);
48416 }
48417 return resultobj;
48418 fail:
48419 return NULL;
48420 }
48421
48422
48423 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48424 PyObject *resultobj = 0;
48425 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48426 wxButton *result = 0 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 PyObject *swig_obj[1] ;
48430
48431 if (!args) SWIG_fail;
48432 swig_obj[0] = args;
48433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48434 if (!SWIG_IsOK(res1)) {
48435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48436 }
48437 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48438 {
48439 PyThreadState* __tstate = wxPyBeginAllowThreads();
48440 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48441 wxPyEndAllowThreads(__tstate);
48442 if (PyErr_Occurred()) SWIG_fail;
48443 }
48444 {
48445 resultobj = wxPyMake_wxObject(result, (bool)0);
48446 }
48447 return resultobj;
48448 fail:
48449 return NULL;
48450 }
48451
48452
48453 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48454 PyObject *resultobj = 0;
48455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48456 wxButton *result = 0 ;
48457 void *argp1 = 0 ;
48458 int res1 = 0 ;
48459 PyObject *swig_obj[1] ;
48460
48461 if (!args) SWIG_fail;
48462 swig_obj[0] = args;
48463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48464 if (!SWIG_IsOK(res1)) {
48465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48466 }
48467 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 {
48475 resultobj = wxPyMake_wxObject(result, (bool)0);
48476 }
48477 return resultobj;
48478 fail:
48479 return NULL;
48480 }
48481
48482
48483 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48484 PyObject *resultobj = 0;
48485 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48486 wxButton *result = 0 ;
48487 void *argp1 = 0 ;
48488 int res1 = 0 ;
48489 PyObject *swig_obj[1] ;
48490
48491 if (!args) SWIG_fail;
48492 swig_obj[0] = args;
48493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48494 if (!SWIG_IsOK(res1)) {
48495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48496 }
48497 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48498 {
48499 PyThreadState* __tstate = wxPyBeginAllowThreads();
48500 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48501 wxPyEndAllowThreads(__tstate);
48502 if (PyErr_Occurred()) SWIG_fail;
48503 }
48504 {
48505 resultobj = wxPyMake_wxObject(result, (bool)0);
48506 }
48507 return resultobj;
48508 fail:
48509 return NULL;
48510 }
48511
48512
48513 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48514 PyObject *resultobj = 0;
48515 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48516 wxButton *result = 0 ;
48517 void *argp1 = 0 ;
48518 int res1 = 0 ;
48519 PyObject *swig_obj[1] ;
48520
48521 if (!args) SWIG_fail;
48522 swig_obj[0] = args;
48523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48524 if (!SWIG_IsOK(res1)) {
48525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48526 }
48527 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48528 {
48529 PyThreadState* __tstate = wxPyBeginAllowThreads();
48530 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48531 wxPyEndAllowThreads(__tstate);
48532 if (PyErr_Occurred()) SWIG_fail;
48533 }
48534 {
48535 resultobj = wxPyMake_wxObject(result, (bool)0);
48536 }
48537 return resultobj;
48538 fail:
48539 return NULL;
48540 }
48541
48542
48543 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48544 PyObject *obj;
48545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48546 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48547 return SWIG_Py_Void();
48548 }
48549
48550 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48551 return SWIG_Python_InitShadowInstance(args);
48552 }
48553
48554 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48555 PyObject *resultobj = 0;
48556 int arg1 = (int) 0 ;
48557 int arg2 = (int) 0 ;
48558 wxGBPosition *result = 0 ;
48559 int val1 ;
48560 int ecode1 = 0 ;
48561 int val2 ;
48562 int ecode2 = 0 ;
48563 PyObject * obj0 = 0 ;
48564 PyObject * obj1 = 0 ;
48565 char * kwnames[] = {
48566 (char *) "row",(char *) "col", NULL
48567 };
48568
48569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48570 if (obj0) {
48571 ecode1 = SWIG_AsVal_int(obj0, &val1);
48572 if (!SWIG_IsOK(ecode1)) {
48573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48574 }
48575 arg1 = static_cast< int >(val1);
48576 }
48577 if (obj1) {
48578 ecode2 = SWIG_AsVal_int(obj1, &val2);
48579 if (!SWIG_IsOK(ecode2)) {
48580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48581 }
48582 arg2 = static_cast< int >(val2);
48583 }
48584 {
48585 PyThreadState* __tstate = wxPyBeginAllowThreads();
48586 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48587 wxPyEndAllowThreads(__tstate);
48588 if (PyErr_Occurred()) SWIG_fail;
48589 }
48590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48591 return resultobj;
48592 fail:
48593 return NULL;
48594 }
48595
48596
48597 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48598 PyObject *resultobj = 0;
48599 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48600 void *argp1 = 0 ;
48601 int res1 = 0 ;
48602 PyObject *swig_obj[1] ;
48603
48604 if (!args) SWIG_fail;
48605 swig_obj[0] = args;
48606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48607 if (!SWIG_IsOK(res1)) {
48608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48609 }
48610 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48611 {
48612 PyThreadState* __tstate = wxPyBeginAllowThreads();
48613 delete arg1;
48614
48615 wxPyEndAllowThreads(__tstate);
48616 if (PyErr_Occurred()) SWIG_fail;
48617 }
48618 resultobj = SWIG_Py_Void();
48619 return resultobj;
48620 fail:
48621 return NULL;
48622 }
48623
48624
48625 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48626 PyObject *resultobj = 0;
48627 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48628 int result;
48629 void *argp1 = 0 ;
48630 int res1 = 0 ;
48631 PyObject *swig_obj[1] ;
48632
48633 if (!args) SWIG_fail;
48634 swig_obj[0] = args;
48635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48636 if (!SWIG_IsOK(res1)) {
48637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48638 }
48639 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48640 {
48641 PyThreadState* __tstate = wxPyBeginAllowThreads();
48642 result = (int)((wxGBPosition const *)arg1)->GetRow();
48643 wxPyEndAllowThreads(__tstate);
48644 if (PyErr_Occurred()) SWIG_fail;
48645 }
48646 resultobj = SWIG_From_int(static_cast< int >(result));
48647 return resultobj;
48648 fail:
48649 return NULL;
48650 }
48651
48652
48653 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48654 PyObject *resultobj = 0;
48655 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48656 int result;
48657 void *argp1 = 0 ;
48658 int res1 = 0 ;
48659 PyObject *swig_obj[1] ;
48660
48661 if (!args) SWIG_fail;
48662 swig_obj[0] = args;
48663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48664 if (!SWIG_IsOK(res1)) {
48665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48666 }
48667 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48668 {
48669 PyThreadState* __tstate = wxPyBeginAllowThreads();
48670 result = (int)((wxGBPosition const *)arg1)->GetCol();
48671 wxPyEndAllowThreads(__tstate);
48672 if (PyErr_Occurred()) SWIG_fail;
48673 }
48674 resultobj = SWIG_From_int(static_cast< int >(result));
48675 return resultobj;
48676 fail:
48677 return NULL;
48678 }
48679
48680
48681 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48682 PyObject *resultobj = 0;
48683 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48684 int arg2 ;
48685 void *argp1 = 0 ;
48686 int res1 = 0 ;
48687 int val2 ;
48688 int ecode2 = 0 ;
48689 PyObject * obj0 = 0 ;
48690 PyObject * obj1 = 0 ;
48691 char * kwnames[] = {
48692 (char *) "self",(char *) "row", NULL
48693 };
48694
48695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48697 if (!SWIG_IsOK(res1)) {
48698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48699 }
48700 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48701 ecode2 = SWIG_AsVal_int(obj1, &val2);
48702 if (!SWIG_IsOK(ecode2)) {
48703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48704 }
48705 arg2 = static_cast< int >(val2);
48706 {
48707 PyThreadState* __tstate = wxPyBeginAllowThreads();
48708 (arg1)->SetRow(arg2);
48709 wxPyEndAllowThreads(__tstate);
48710 if (PyErr_Occurred()) SWIG_fail;
48711 }
48712 resultobj = SWIG_Py_Void();
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48720 PyObject *resultobj = 0;
48721 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48722 int arg2 ;
48723 void *argp1 = 0 ;
48724 int res1 = 0 ;
48725 int val2 ;
48726 int ecode2 = 0 ;
48727 PyObject * obj0 = 0 ;
48728 PyObject * obj1 = 0 ;
48729 char * kwnames[] = {
48730 (char *) "self",(char *) "col", NULL
48731 };
48732
48733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48735 if (!SWIG_IsOK(res1)) {
48736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48737 }
48738 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48739 ecode2 = SWIG_AsVal_int(obj1, &val2);
48740 if (!SWIG_IsOK(ecode2)) {
48741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48742 }
48743 arg2 = static_cast< int >(val2);
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 (arg1)->SetCol(arg2);
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48760 PyObject *arg2 = (PyObject *) 0 ;
48761 bool result;
48762 void *argp1 = 0 ;
48763 int res1 = 0 ;
48764 PyObject * obj0 = 0 ;
48765 PyObject * obj1 = 0 ;
48766 char * kwnames[] = {
48767 (char *) "self",(char *) "other", NULL
48768 };
48769
48770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48774 }
48775 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48776 arg2 = obj1;
48777 {
48778 result = (bool)wxGBPosition___eq__(arg1,arg2);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 {
48782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48783 }
48784 return resultobj;
48785 fail:
48786 return NULL;
48787 }
48788
48789
48790 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48791 PyObject *resultobj = 0;
48792 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48793 PyObject *arg2 = (PyObject *) 0 ;
48794 bool result;
48795 void *argp1 = 0 ;
48796 int res1 = 0 ;
48797 PyObject * obj0 = 0 ;
48798 PyObject * obj1 = 0 ;
48799 char * kwnames[] = {
48800 (char *) "self",(char *) "other", NULL
48801 };
48802
48803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48805 if (!SWIG_IsOK(res1)) {
48806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48807 }
48808 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48809 arg2 = obj1;
48810 {
48811 result = (bool)wxGBPosition___ne__(arg1,arg2);
48812 if (PyErr_Occurred()) SWIG_fail;
48813 }
48814 {
48815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48816 }
48817 return resultobj;
48818 fail:
48819 return NULL;
48820 }
48821
48822
48823 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48824 PyObject *resultobj = 0;
48825 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48826 int arg2 = (int) 0 ;
48827 int arg3 = (int) 0 ;
48828 void *argp1 = 0 ;
48829 int res1 = 0 ;
48830 int val2 ;
48831 int ecode2 = 0 ;
48832 int val3 ;
48833 int ecode3 = 0 ;
48834 PyObject * obj0 = 0 ;
48835 PyObject * obj1 = 0 ;
48836 PyObject * obj2 = 0 ;
48837 char * kwnames[] = {
48838 (char *) "self",(char *) "row",(char *) "col", NULL
48839 };
48840
48841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48843 if (!SWIG_IsOK(res1)) {
48844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48845 }
48846 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48847 if (obj1) {
48848 ecode2 = SWIG_AsVal_int(obj1, &val2);
48849 if (!SWIG_IsOK(ecode2)) {
48850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48851 }
48852 arg2 = static_cast< int >(val2);
48853 }
48854 if (obj2) {
48855 ecode3 = SWIG_AsVal_int(obj2, &val3);
48856 if (!SWIG_IsOK(ecode3)) {
48857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48858 }
48859 arg3 = static_cast< int >(val3);
48860 }
48861 {
48862 PyThreadState* __tstate = wxPyBeginAllowThreads();
48863 wxGBPosition_Set(arg1,arg2,arg3);
48864 wxPyEndAllowThreads(__tstate);
48865 if (PyErr_Occurred()) SWIG_fail;
48866 }
48867 resultobj = SWIG_Py_Void();
48868 return resultobj;
48869 fail:
48870 return NULL;
48871 }
48872
48873
48874 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48875 PyObject *resultobj = 0;
48876 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48877 PyObject *result = 0 ;
48878 void *argp1 = 0 ;
48879 int res1 = 0 ;
48880 PyObject *swig_obj[1] ;
48881
48882 if (!args) SWIG_fail;
48883 swig_obj[0] = args;
48884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48885 if (!SWIG_IsOK(res1)) {
48886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48887 }
48888 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48889 {
48890 PyThreadState* __tstate = wxPyBeginAllowThreads();
48891 result = (PyObject *)wxGBPosition_Get(arg1);
48892 wxPyEndAllowThreads(__tstate);
48893 if (PyErr_Occurred()) SWIG_fail;
48894 }
48895 resultobj = result;
48896 return resultobj;
48897 fail:
48898 return NULL;
48899 }
48900
48901
48902 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48903 PyObject *obj;
48904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48905 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48906 return SWIG_Py_Void();
48907 }
48908
48909 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48910 return SWIG_Python_InitShadowInstance(args);
48911 }
48912
48913 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48914 PyObject *resultobj = 0;
48915 int arg1 = (int) 1 ;
48916 int arg2 = (int) 1 ;
48917 wxGBSpan *result = 0 ;
48918 int val1 ;
48919 int ecode1 = 0 ;
48920 int val2 ;
48921 int ecode2 = 0 ;
48922 PyObject * obj0 = 0 ;
48923 PyObject * obj1 = 0 ;
48924 char * kwnames[] = {
48925 (char *) "rowspan",(char *) "colspan", NULL
48926 };
48927
48928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48929 if (obj0) {
48930 ecode1 = SWIG_AsVal_int(obj0, &val1);
48931 if (!SWIG_IsOK(ecode1)) {
48932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48933 }
48934 arg1 = static_cast< int >(val1);
48935 }
48936 if (obj1) {
48937 ecode2 = SWIG_AsVal_int(obj1, &val2);
48938 if (!SWIG_IsOK(ecode2)) {
48939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48940 }
48941 arg2 = static_cast< int >(val2);
48942 }
48943 {
48944 PyThreadState* __tstate = wxPyBeginAllowThreads();
48945 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48946 wxPyEndAllowThreads(__tstate);
48947 if (PyErr_Occurred()) SWIG_fail;
48948 }
48949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48957 PyObject *resultobj = 0;
48958 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48959 void *argp1 = 0 ;
48960 int res1 = 0 ;
48961 PyObject *swig_obj[1] ;
48962
48963 if (!args) SWIG_fail;
48964 swig_obj[0] = args;
48965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48966 if (!SWIG_IsOK(res1)) {
48967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48968 }
48969 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48970 {
48971 PyThreadState* __tstate = wxPyBeginAllowThreads();
48972 delete arg1;
48973
48974 wxPyEndAllowThreads(__tstate);
48975 if (PyErr_Occurred()) SWIG_fail;
48976 }
48977 resultobj = SWIG_Py_Void();
48978 return resultobj;
48979 fail:
48980 return NULL;
48981 }
48982
48983
48984 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48985 PyObject *resultobj = 0;
48986 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48987 int result;
48988 void *argp1 = 0 ;
48989 int res1 = 0 ;
48990 PyObject *swig_obj[1] ;
48991
48992 if (!args) SWIG_fail;
48993 swig_obj[0] = args;
48994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48995 if (!SWIG_IsOK(res1)) {
48996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48997 }
48998 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48999 {
49000 PyThreadState* __tstate = wxPyBeginAllowThreads();
49001 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49002 wxPyEndAllowThreads(__tstate);
49003 if (PyErr_Occurred()) SWIG_fail;
49004 }
49005 resultobj = SWIG_From_int(static_cast< int >(result));
49006 return resultobj;
49007 fail:
49008 return NULL;
49009 }
49010
49011
49012 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49013 PyObject *resultobj = 0;
49014 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49015 int result;
49016 void *argp1 = 0 ;
49017 int res1 = 0 ;
49018 PyObject *swig_obj[1] ;
49019
49020 if (!args) SWIG_fail;
49021 swig_obj[0] = args;
49022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49023 if (!SWIG_IsOK(res1)) {
49024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49025 }
49026 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49027 {
49028 PyThreadState* __tstate = wxPyBeginAllowThreads();
49029 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49030 wxPyEndAllowThreads(__tstate);
49031 if (PyErr_Occurred()) SWIG_fail;
49032 }
49033 resultobj = SWIG_From_int(static_cast< int >(result));
49034 return resultobj;
49035 fail:
49036 return NULL;
49037 }
49038
49039
49040 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49041 PyObject *resultobj = 0;
49042 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49043 int arg2 ;
49044 void *argp1 = 0 ;
49045 int res1 = 0 ;
49046 int val2 ;
49047 int ecode2 = 0 ;
49048 PyObject * obj0 = 0 ;
49049 PyObject * obj1 = 0 ;
49050 char * kwnames[] = {
49051 (char *) "self",(char *) "rowspan", NULL
49052 };
49053
49054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49058 }
49059 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49060 ecode2 = SWIG_AsVal_int(obj1, &val2);
49061 if (!SWIG_IsOK(ecode2)) {
49062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49063 }
49064 arg2 = static_cast< int >(val2);
49065 {
49066 PyThreadState* __tstate = wxPyBeginAllowThreads();
49067 (arg1)->SetRowspan(arg2);
49068 wxPyEndAllowThreads(__tstate);
49069 if (PyErr_Occurred()) SWIG_fail;
49070 }
49071 resultobj = SWIG_Py_Void();
49072 return resultobj;
49073 fail:
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49079 PyObject *resultobj = 0;
49080 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49081 int arg2 ;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 int val2 ;
49085 int ecode2 = 0 ;
49086 PyObject * obj0 = 0 ;
49087 PyObject * obj1 = 0 ;
49088 char * kwnames[] = {
49089 (char *) "self",(char *) "colspan", NULL
49090 };
49091
49092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49096 }
49097 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49098 ecode2 = SWIG_AsVal_int(obj1, &val2);
49099 if (!SWIG_IsOK(ecode2)) {
49100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49101 }
49102 arg2 = static_cast< int >(val2);
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 (arg1)->SetColspan(arg2);
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_Py_Void();
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49117 PyObject *resultobj = 0;
49118 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49119 PyObject *arg2 = (PyObject *) 0 ;
49120 bool result;
49121 void *argp1 = 0 ;
49122 int res1 = 0 ;
49123 PyObject * obj0 = 0 ;
49124 PyObject * obj1 = 0 ;
49125 char * kwnames[] = {
49126 (char *) "self",(char *) "other", NULL
49127 };
49128
49129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49131 if (!SWIG_IsOK(res1)) {
49132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49133 }
49134 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49135 arg2 = obj1;
49136 {
49137 result = (bool)wxGBSpan___eq__(arg1,arg2);
49138 if (PyErr_Occurred()) SWIG_fail;
49139 }
49140 {
49141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49142 }
49143 return resultobj;
49144 fail:
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49150 PyObject *resultobj = 0;
49151 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49152 PyObject *arg2 = (PyObject *) 0 ;
49153 bool result;
49154 void *argp1 = 0 ;
49155 int res1 = 0 ;
49156 PyObject * obj0 = 0 ;
49157 PyObject * obj1 = 0 ;
49158 char * kwnames[] = {
49159 (char *) "self",(char *) "other", NULL
49160 };
49161
49162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49164 if (!SWIG_IsOK(res1)) {
49165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49166 }
49167 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49168 arg2 = obj1;
49169 {
49170 result = (bool)wxGBSpan___ne__(arg1,arg2);
49171 if (PyErr_Occurred()) SWIG_fail;
49172 }
49173 {
49174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49175 }
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49183 PyObject *resultobj = 0;
49184 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49185 int arg2 = (int) 1 ;
49186 int arg3 = (int) 1 ;
49187 void *argp1 = 0 ;
49188 int res1 = 0 ;
49189 int val2 ;
49190 int ecode2 = 0 ;
49191 int val3 ;
49192 int ecode3 = 0 ;
49193 PyObject * obj0 = 0 ;
49194 PyObject * obj1 = 0 ;
49195 PyObject * obj2 = 0 ;
49196 char * kwnames[] = {
49197 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49198 };
49199
49200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49202 if (!SWIG_IsOK(res1)) {
49203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49204 }
49205 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49206 if (obj1) {
49207 ecode2 = SWIG_AsVal_int(obj1, &val2);
49208 if (!SWIG_IsOK(ecode2)) {
49209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49210 }
49211 arg2 = static_cast< int >(val2);
49212 }
49213 if (obj2) {
49214 ecode3 = SWIG_AsVal_int(obj2, &val3);
49215 if (!SWIG_IsOK(ecode3)) {
49216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49217 }
49218 arg3 = static_cast< int >(val3);
49219 }
49220 {
49221 PyThreadState* __tstate = wxPyBeginAllowThreads();
49222 wxGBSpan_Set(arg1,arg2,arg3);
49223 wxPyEndAllowThreads(__tstate);
49224 if (PyErr_Occurred()) SWIG_fail;
49225 }
49226 resultobj = SWIG_Py_Void();
49227 return resultobj;
49228 fail:
49229 return NULL;
49230 }
49231
49232
49233 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49234 PyObject *resultobj = 0;
49235 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49236 PyObject *result = 0 ;
49237 void *argp1 = 0 ;
49238 int res1 = 0 ;
49239 PyObject *swig_obj[1] ;
49240
49241 if (!args) SWIG_fail;
49242 swig_obj[0] = args;
49243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49244 if (!SWIG_IsOK(res1)) {
49245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49246 }
49247 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49248 {
49249 PyThreadState* __tstate = wxPyBeginAllowThreads();
49250 result = (PyObject *)wxGBSpan_Get(arg1);
49251 wxPyEndAllowThreads(__tstate);
49252 if (PyErr_Occurred()) SWIG_fail;
49253 }
49254 resultobj = result;
49255 return resultobj;
49256 fail:
49257 return NULL;
49258 }
49259
49260
49261 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49262 PyObject *obj;
49263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49264 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49265 return SWIG_Py_Void();
49266 }
49267
49268 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49269 return SWIG_Python_InitShadowInstance(args);
49270 }
49271
49272 SWIGINTERN int DefaultSpan_set(PyObject *) {
49273 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49274 return 1;
49275 }
49276
49277
49278 SWIGINTERN PyObject *DefaultSpan_get(void) {
49279 PyObject *pyobj = 0;
49280
49281 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49282 return pyobj;
49283 }
49284
49285
49286 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49287 PyObject *resultobj = 0;
49288 wxGBSizerItem *result = 0 ;
49289
49290 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49291 {
49292 PyThreadState* __tstate = wxPyBeginAllowThreads();
49293 result = (wxGBSizerItem *)new wxGBSizerItem();
49294 wxPyEndAllowThreads(__tstate);
49295 if (PyErr_Occurred()) SWIG_fail;
49296 }
49297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49298 return resultobj;
49299 fail:
49300 return NULL;
49301 }
49302
49303
49304 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49305 PyObject *resultobj = 0;
49306 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49307 void *argp1 = 0 ;
49308 int res1 = 0 ;
49309 PyObject *swig_obj[1] ;
49310
49311 if (!args) SWIG_fail;
49312 swig_obj[0] = args;
49313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49314 if (!SWIG_IsOK(res1)) {
49315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49316 }
49317 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49318 {
49319 PyThreadState* __tstate = wxPyBeginAllowThreads();
49320 delete arg1;
49321
49322 wxPyEndAllowThreads(__tstate);
49323 if (PyErr_Occurred()) SWIG_fail;
49324 }
49325 resultobj = SWIG_Py_Void();
49326 return resultobj;
49327 fail:
49328 return NULL;
49329 }
49330
49331
49332 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49333 PyObject *resultobj = 0;
49334 wxWindow *arg1 = (wxWindow *) 0 ;
49335 wxGBPosition *arg2 = 0 ;
49336 wxGBSpan *arg3 = 0 ;
49337 int arg4 ;
49338 int arg5 ;
49339 PyObject *arg6 = (PyObject *) NULL ;
49340 wxGBSizerItem *result = 0 ;
49341 void *argp1 = 0 ;
49342 int res1 = 0 ;
49343 wxGBPosition temp2 ;
49344 wxGBSpan temp3 ;
49345 int val4 ;
49346 int ecode4 = 0 ;
49347 int val5 ;
49348 int ecode5 = 0 ;
49349 PyObject * obj0 = 0 ;
49350 PyObject * obj1 = 0 ;
49351 PyObject * obj2 = 0 ;
49352 PyObject * obj3 = 0 ;
49353 PyObject * obj4 = 0 ;
49354 PyObject * obj5 = 0 ;
49355 char * kwnames[] = {
49356 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49357 };
49358
49359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49363 }
49364 arg1 = reinterpret_cast< wxWindow * >(argp1);
49365 {
49366 arg2 = &temp2;
49367 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49368 }
49369 {
49370 arg3 = &temp3;
49371 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49372 }
49373 ecode4 = SWIG_AsVal_int(obj3, &val4);
49374 if (!SWIG_IsOK(ecode4)) {
49375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49376 }
49377 arg4 = static_cast< int >(val4);
49378 ecode5 = SWIG_AsVal_int(obj4, &val5);
49379 if (!SWIG_IsOK(ecode5)) {
49380 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49381 }
49382 arg5 = static_cast< int >(val5);
49383 if (obj5) {
49384 arg6 = obj5;
49385 }
49386 {
49387 PyThreadState* __tstate = wxPyBeginAllowThreads();
49388 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49389 wxPyEndAllowThreads(__tstate);
49390 if (PyErr_Occurred()) SWIG_fail;
49391 }
49392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49400 PyObject *resultobj = 0;
49401 wxSizer *arg1 = (wxSizer *) 0 ;
49402 wxGBPosition *arg2 = 0 ;
49403 wxGBSpan *arg3 = 0 ;
49404 int arg4 ;
49405 int arg5 ;
49406 PyObject *arg6 = (PyObject *) NULL ;
49407 wxGBSizerItem *result = 0 ;
49408 int res1 = 0 ;
49409 wxGBPosition temp2 ;
49410 wxGBSpan temp3 ;
49411 int val4 ;
49412 int ecode4 = 0 ;
49413 int val5 ;
49414 int ecode5 = 0 ;
49415 PyObject * obj0 = 0 ;
49416 PyObject * obj1 = 0 ;
49417 PyObject * obj2 = 0 ;
49418 PyObject * obj3 = 0 ;
49419 PyObject * obj4 = 0 ;
49420 PyObject * obj5 = 0 ;
49421 char * kwnames[] = {
49422 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49423 };
49424
49425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49426 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49427 if (!SWIG_IsOK(res1)) {
49428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49429 }
49430 {
49431 arg2 = &temp2;
49432 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49433 }
49434 {
49435 arg3 = &temp3;
49436 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49437 }
49438 ecode4 = SWIG_AsVal_int(obj3, &val4);
49439 if (!SWIG_IsOK(ecode4)) {
49440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49441 }
49442 arg4 = static_cast< int >(val4);
49443 ecode5 = SWIG_AsVal_int(obj4, &val5);
49444 if (!SWIG_IsOK(ecode5)) {
49445 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49446 }
49447 arg5 = static_cast< int >(val5);
49448 if (obj5) {
49449 arg6 = obj5;
49450 }
49451 {
49452 PyThreadState* __tstate = wxPyBeginAllowThreads();
49453 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49454 wxPyEndAllowThreads(__tstate);
49455 if (PyErr_Occurred()) SWIG_fail;
49456 }
49457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49465 PyObject *resultobj = 0;
49466 int arg1 ;
49467 int arg2 ;
49468 wxGBPosition *arg3 = 0 ;
49469 wxGBSpan *arg4 = 0 ;
49470 int arg5 ;
49471 int arg6 ;
49472 PyObject *arg7 = (PyObject *) NULL ;
49473 wxGBSizerItem *result = 0 ;
49474 int val1 ;
49475 int ecode1 = 0 ;
49476 int val2 ;
49477 int ecode2 = 0 ;
49478 wxGBPosition temp3 ;
49479 wxGBSpan temp4 ;
49480 int val5 ;
49481 int ecode5 = 0 ;
49482 int val6 ;
49483 int ecode6 = 0 ;
49484 PyObject * obj0 = 0 ;
49485 PyObject * obj1 = 0 ;
49486 PyObject * obj2 = 0 ;
49487 PyObject * obj3 = 0 ;
49488 PyObject * obj4 = 0 ;
49489 PyObject * obj5 = 0 ;
49490 PyObject * obj6 = 0 ;
49491 char * kwnames[] = {
49492 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49493 };
49494
49495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49496 ecode1 = SWIG_AsVal_int(obj0, &val1);
49497 if (!SWIG_IsOK(ecode1)) {
49498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49499 }
49500 arg1 = static_cast< int >(val1);
49501 ecode2 = SWIG_AsVal_int(obj1, &val2);
49502 if (!SWIG_IsOK(ecode2)) {
49503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49504 }
49505 arg2 = static_cast< int >(val2);
49506 {
49507 arg3 = &temp3;
49508 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49509 }
49510 {
49511 arg4 = &temp4;
49512 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49513 }
49514 ecode5 = SWIG_AsVal_int(obj4, &val5);
49515 if (!SWIG_IsOK(ecode5)) {
49516 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49517 }
49518 arg5 = static_cast< int >(val5);
49519 ecode6 = SWIG_AsVal_int(obj5, &val6);
49520 if (!SWIG_IsOK(ecode6)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49522 }
49523 arg6 = static_cast< int >(val6);
49524 if (obj6) {
49525 arg7 = obj6;
49526 }
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 PyObject *resultobj = 0;
49542 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49543 wxGBPosition result;
49544 void *argp1 = 0 ;
49545 int res1 = 0 ;
49546 PyObject *swig_obj[1] ;
49547
49548 if (!args) SWIG_fail;
49549 swig_obj[0] = args;
49550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49551 if (!SWIG_IsOK(res1)) {
49552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49553 }
49554 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49555 {
49556 PyThreadState* __tstate = wxPyBeginAllowThreads();
49557 result = ((wxGBSizerItem const *)arg1)->GetPos();
49558 wxPyEndAllowThreads(__tstate);
49559 if (PyErr_Occurred()) SWIG_fail;
49560 }
49561 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49562 return resultobj;
49563 fail:
49564 return NULL;
49565 }
49566
49567
49568 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49569 PyObject *resultobj = 0;
49570 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49571 wxGBSpan result;
49572 void *argp1 = 0 ;
49573 int res1 = 0 ;
49574 PyObject *swig_obj[1] ;
49575
49576 if (!args) SWIG_fail;
49577 swig_obj[0] = args;
49578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49579 if (!SWIG_IsOK(res1)) {
49580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49581 }
49582 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49597 PyObject *resultobj = 0;
49598 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49599 wxGBPosition *arg2 = 0 ;
49600 bool result;
49601 void *argp1 = 0 ;
49602 int res1 = 0 ;
49603 wxGBPosition temp2 ;
49604 PyObject * obj0 = 0 ;
49605 PyObject * obj1 = 0 ;
49606 char * kwnames[] = {
49607 (char *) "self",(char *) "pos", NULL
49608 };
49609
49610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49612 if (!SWIG_IsOK(res1)) {
49613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49614 }
49615 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49616 {
49617 arg2 = &temp2;
49618 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49619 }
49620 {
49621 PyThreadState* __tstate = wxPyBeginAllowThreads();
49622 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49623 wxPyEndAllowThreads(__tstate);
49624 if (PyErr_Occurred()) SWIG_fail;
49625 }
49626 {
49627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49628 }
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49636 PyObject *resultobj = 0;
49637 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49638 wxGBSpan *arg2 = 0 ;
49639 bool result;
49640 void *argp1 = 0 ;
49641 int res1 = 0 ;
49642 wxGBSpan temp2 ;
49643 PyObject * obj0 = 0 ;
49644 PyObject * obj1 = 0 ;
49645 char * kwnames[] = {
49646 (char *) "self",(char *) "span", NULL
49647 };
49648
49649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49653 }
49654 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49655 {
49656 arg2 = &temp2;
49657 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49658 }
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 {
49666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49667 }
49668 return resultobj;
49669 fail:
49670 return NULL;
49671 }
49672
49673
49674 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49675 PyObject *resultobj = 0;
49676 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49677 wxGBSizerItem *arg2 = 0 ;
49678 bool result;
49679 void *argp1 = 0 ;
49680 int res1 = 0 ;
49681 void *argp2 = 0 ;
49682 int res2 = 0 ;
49683 PyObject * obj0 = 0 ;
49684 PyObject * obj1 = 0 ;
49685 char * kwnames[] = {
49686 (char *) "self",(char *) "other", NULL
49687 };
49688
49689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49691 if (!SWIG_IsOK(res1)) {
49692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49693 }
49694 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49696 if (!SWIG_IsOK(res2)) {
49697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49698 }
49699 if (!argp2) {
49700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49701 }
49702 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49703 {
49704 PyThreadState* __tstate = wxPyBeginAllowThreads();
49705 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49706 wxPyEndAllowThreads(__tstate);
49707 if (PyErr_Occurred()) SWIG_fail;
49708 }
49709 {
49710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49711 }
49712 return resultobj;
49713 fail:
49714 return NULL;
49715 }
49716
49717
49718 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49719 PyObject *resultobj = 0;
49720 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49721 wxGBPosition *arg2 = 0 ;
49722 wxGBSpan *arg3 = 0 ;
49723 bool result;
49724 void *argp1 = 0 ;
49725 int res1 = 0 ;
49726 wxGBPosition temp2 ;
49727 wxGBSpan temp3 ;
49728 PyObject * obj0 = 0 ;
49729 PyObject * obj1 = 0 ;
49730 PyObject * obj2 = 0 ;
49731 char * kwnames[] = {
49732 (char *) "self",(char *) "pos",(char *) "span", NULL
49733 };
49734
49735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49737 if (!SWIG_IsOK(res1)) {
49738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49739 }
49740 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49741 {
49742 arg2 = &temp2;
49743 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49744 }
49745 {
49746 arg3 = &temp3;
49747 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49748 }
49749 {
49750 PyThreadState* __tstate = wxPyBeginAllowThreads();
49751 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49752 wxPyEndAllowThreads(__tstate);
49753 if (PyErr_Occurred()) SWIG_fail;
49754 }
49755 {
49756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49757 }
49758 return resultobj;
49759 fail:
49760 return NULL;
49761 }
49762
49763
49764 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49765 PyObject *resultobj = 0;
49766 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49767 wxGBPosition result;
49768 void *argp1 = 0 ;
49769 int res1 = 0 ;
49770 PyObject *swig_obj[1] ;
49771
49772 if (!args) SWIG_fail;
49773 swig_obj[0] = args;
49774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49775 if (!SWIG_IsOK(res1)) {
49776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49777 }
49778 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49779 {
49780 PyThreadState* __tstate = wxPyBeginAllowThreads();
49781 result = wxGBSizerItem_GetEndPos(arg1);
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49793 PyObject *resultobj = 0;
49794 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49795 wxGridBagSizer *result = 0 ;
49796 void *argp1 = 0 ;
49797 int res1 = 0 ;
49798 PyObject *swig_obj[1] ;
49799
49800 if (!args) SWIG_fail;
49801 swig_obj[0] = args;
49802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49805 }
49806 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49821 PyObject *resultobj = 0;
49822 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49823 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49824 void *argp1 = 0 ;
49825 int res1 = 0 ;
49826 void *argp2 = 0 ;
49827 int res2 = 0 ;
49828 PyObject * obj0 = 0 ;
49829 PyObject * obj1 = 0 ;
49830 char * kwnames[] = {
49831 (char *) "self",(char *) "sizer", NULL
49832 };
49833
49834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49838 }
49839 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49841 if (!SWIG_IsOK(res2)) {
49842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49843 }
49844 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49845 {
49846 PyThreadState* __tstate = wxPyBeginAllowThreads();
49847 (arg1)->SetGBSizer(arg2);
49848 wxPyEndAllowThreads(__tstate);
49849 if (PyErr_Occurred()) SWIG_fail;
49850 }
49851 resultobj = SWIG_Py_Void();
49852 return resultobj;
49853 fail:
49854 return NULL;
49855 }
49856
49857
49858 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49859 PyObject *obj;
49860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49861 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49862 return SWIG_Py_Void();
49863 }
49864
49865 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49866 return SWIG_Python_InitShadowInstance(args);
49867 }
49868
49869 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49870 PyObject *resultobj = 0;
49871 int arg1 = (int) 0 ;
49872 int arg2 = (int) 0 ;
49873 wxGridBagSizer *result = 0 ;
49874 int val1 ;
49875 int ecode1 = 0 ;
49876 int val2 ;
49877 int ecode2 = 0 ;
49878 PyObject * obj0 = 0 ;
49879 PyObject * obj1 = 0 ;
49880 char * kwnames[] = {
49881 (char *) "vgap",(char *) "hgap", NULL
49882 };
49883
49884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49885 if (obj0) {
49886 ecode1 = SWIG_AsVal_int(obj0, &val1);
49887 if (!SWIG_IsOK(ecode1)) {
49888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49889 }
49890 arg1 = static_cast< int >(val1);
49891 }
49892 if (obj1) {
49893 ecode2 = SWIG_AsVal_int(obj1, &val2);
49894 if (!SWIG_IsOK(ecode2)) {
49895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49896 }
49897 arg2 = static_cast< int >(val2);
49898 }
49899 {
49900 PyThreadState* __tstate = wxPyBeginAllowThreads();
49901 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49902 wxPyEndAllowThreads(__tstate);
49903 if (PyErr_Occurred()) SWIG_fail;
49904 }
49905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49906 return resultobj;
49907 fail:
49908 return NULL;
49909 }
49910
49911
49912 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49913 PyObject *resultobj = 0;
49914 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49915 PyObject *arg2 = (PyObject *) 0 ;
49916 wxGBPosition *arg3 = 0 ;
49917 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49918 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49919 int arg5 = (int) 0 ;
49920 int arg6 = (int) 0 ;
49921 PyObject *arg7 = (PyObject *) NULL ;
49922 wxGBSizerItem *result = 0 ;
49923 void *argp1 = 0 ;
49924 int res1 = 0 ;
49925 wxGBPosition temp3 ;
49926 wxGBSpan temp4 ;
49927 int val5 ;
49928 int ecode5 = 0 ;
49929 int val6 ;
49930 int ecode6 = 0 ;
49931 PyObject * obj0 = 0 ;
49932 PyObject * obj1 = 0 ;
49933 PyObject * obj2 = 0 ;
49934 PyObject * obj3 = 0 ;
49935 PyObject * obj4 = 0 ;
49936 PyObject * obj5 = 0 ;
49937 PyObject * obj6 = 0 ;
49938 char * kwnames[] = {
49939 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49940 };
49941
49942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49944 if (!SWIG_IsOK(res1)) {
49945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49946 }
49947 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49948 arg2 = obj1;
49949 {
49950 arg3 = &temp3;
49951 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49952 }
49953 if (obj3) {
49954 {
49955 arg4 = &temp4;
49956 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49957 }
49958 }
49959 if (obj4) {
49960 ecode5 = SWIG_AsVal_int(obj4, &val5);
49961 if (!SWIG_IsOK(ecode5)) {
49962 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49963 }
49964 arg5 = static_cast< int >(val5);
49965 }
49966 if (obj5) {
49967 ecode6 = SWIG_AsVal_int(obj5, &val6);
49968 if (!SWIG_IsOK(ecode6)) {
49969 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49970 }
49971 arg6 = static_cast< int >(val6);
49972 }
49973 if (obj6) {
49974 arg7 = obj6;
49975 }
49976 {
49977 PyThreadState* __tstate = wxPyBeginAllowThreads();
49978 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49979 wxPyEndAllowThreads(__tstate);
49980 if (PyErr_Occurred()) SWIG_fail;
49981 }
49982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49983 return resultobj;
49984 fail:
49985 return NULL;
49986 }
49987
49988
49989 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49990 PyObject *resultobj = 0;
49991 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49992 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49993 wxGBSizerItem *result = 0 ;
49994 void *argp1 = 0 ;
49995 int res1 = 0 ;
49996 int res2 = 0 ;
49997 PyObject * obj0 = 0 ;
49998 PyObject * obj1 = 0 ;
49999 char * kwnames[] = {
50000 (char *) "self",(char *) "item", NULL
50001 };
50002
50003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50005 if (!SWIG_IsOK(res1)) {
50006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50007 }
50008 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50009 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50010 if (!SWIG_IsOK(res2)) {
50011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50012 }
50013 {
50014 PyThreadState* __tstate = wxPyBeginAllowThreads();
50015 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50016 wxPyEndAllowThreads(__tstate);
50017 if (PyErr_Occurred()) SWIG_fail;
50018 }
50019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50020 return resultobj;
50021 fail:
50022 return NULL;
50023 }
50024
50025
50026 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50027 PyObject *resultobj = 0;
50028 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50029 int arg2 ;
50030 int arg3 ;
50031 wxSize result;
50032 void *argp1 = 0 ;
50033 int res1 = 0 ;
50034 int val2 ;
50035 int ecode2 = 0 ;
50036 int val3 ;
50037 int ecode3 = 0 ;
50038 PyObject * obj0 = 0 ;
50039 PyObject * obj1 = 0 ;
50040 PyObject * obj2 = 0 ;
50041 char * kwnames[] = {
50042 (char *) "self",(char *) "row",(char *) "col", NULL
50043 };
50044
50045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50047 if (!SWIG_IsOK(res1)) {
50048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50049 }
50050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50051 ecode2 = SWIG_AsVal_int(obj1, &val2);
50052 if (!SWIG_IsOK(ecode2)) {
50053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50054 }
50055 arg2 = static_cast< int >(val2);
50056 ecode3 = SWIG_AsVal_int(obj2, &val3);
50057 if (!SWIG_IsOK(ecode3)) {
50058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50059 }
50060 arg3 = static_cast< int >(val3);
50061 {
50062 PyThreadState* __tstate = wxPyBeginAllowThreads();
50063 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50064 wxPyEndAllowThreads(__tstate);
50065 if (PyErr_Occurred()) SWIG_fail;
50066 }
50067 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50068 return resultobj;
50069 fail:
50070 return NULL;
50071 }
50072
50073
50074 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50075 PyObject *resultobj = 0;
50076 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50077 wxSize result;
50078 void *argp1 = 0 ;
50079 int res1 = 0 ;
50080 PyObject *swig_obj[1] ;
50081
50082 if (!args) SWIG_fail;
50083 swig_obj[0] = args;
50084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50085 if (!SWIG_IsOK(res1)) {
50086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50087 }
50088 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50089 {
50090 PyThreadState* __tstate = wxPyBeginAllowThreads();
50091 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50092 wxPyEndAllowThreads(__tstate);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50105 wxSize *arg2 = 0 ;
50106 void *argp1 = 0 ;
50107 int res1 = 0 ;
50108 wxSize temp2 ;
50109 PyObject * obj0 = 0 ;
50110 PyObject * obj1 = 0 ;
50111 char * kwnames[] = {
50112 (char *) "self",(char *) "sz", NULL
50113 };
50114
50115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50117 if (!SWIG_IsOK(res1)) {
50118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50119 }
50120 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50121 {
50122 arg2 = &temp2;
50123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50124 }
50125 {
50126 PyThreadState* __tstate = wxPyBeginAllowThreads();
50127 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50128 wxPyEndAllowThreads(__tstate);
50129 if (PyErr_Occurred()) SWIG_fail;
50130 }
50131 resultobj = SWIG_Py_Void();
50132 return resultobj;
50133 fail:
50134 return NULL;
50135 }
50136
50137
50138 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50139 PyObject *resultobj = 0;
50140 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50141 wxWindow *arg2 = (wxWindow *) 0 ;
50142 wxGBPosition result;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 void *argp2 = 0 ;
50146 int res2 = 0 ;
50147
50148 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50152 }
50153 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50154 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50155 if (!SWIG_IsOK(res2)) {
50156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50157 }
50158 arg2 = reinterpret_cast< wxWindow * >(argp2);
50159 {
50160 PyThreadState* __tstate = wxPyBeginAllowThreads();
50161 result = (arg1)->GetItemPosition(arg2);
50162 wxPyEndAllowThreads(__tstate);
50163 if (PyErr_Occurred()) SWIG_fail;
50164 }
50165 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50173 PyObject *resultobj = 0;
50174 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50175 wxSizer *arg2 = (wxSizer *) 0 ;
50176 wxGBPosition result;
50177 void *argp1 = 0 ;
50178 int res1 = 0 ;
50179 void *argp2 = 0 ;
50180 int res2 = 0 ;
50181
50182 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50184 if (!SWIG_IsOK(res1)) {
50185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50186 }
50187 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50188 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50189 if (!SWIG_IsOK(res2)) {
50190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50191 }
50192 arg2 = reinterpret_cast< wxSizer * >(argp2);
50193 {
50194 PyThreadState* __tstate = wxPyBeginAllowThreads();
50195 result = (arg1)->GetItemPosition(arg2);
50196 wxPyEndAllowThreads(__tstate);
50197 if (PyErr_Occurred()) SWIG_fail;
50198 }
50199 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50207 PyObject *resultobj = 0;
50208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50209 size_t arg2 ;
50210 wxGBPosition result;
50211 void *argp1 = 0 ;
50212 int res1 = 0 ;
50213 size_t val2 ;
50214 int ecode2 = 0 ;
50215
50216 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50218 if (!SWIG_IsOK(res1)) {
50219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50220 }
50221 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50222 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50223 if (!SWIG_IsOK(ecode2)) {
50224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50225 }
50226 arg2 = static_cast< size_t >(val2);
50227 {
50228 PyThreadState* __tstate = wxPyBeginAllowThreads();
50229 result = (arg1)->GetItemPosition(arg2);
50230 wxPyEndAllowThreads(__tstate);
50231 if (PyErr_Occurred()) SWIG_fail;
50232 }
50233 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50234 return resultobj;
50235 fail:
50236 return NULL;
50237 }
50238
50239
50240 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50241 int argc;
50242 PyObject *argv[3];
50243
50244 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50245 --argc;
50246 if (argc == 2) {
50247 int _v = 0;
50248 {
50249 void *vptr = 0;
50250 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50251 _v = SWIG_CheckState(res);
50252 }
50253 if (!_v) goto check_1;
50254 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50255 }
50256 check_1:
50257
50258 if (argc == 2) {
50259 int _v = 0;
50260 {
50261 void *vptr = 0;
50262 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50263 _v = SWIG_CheckState(res);
50264 }
50265 if (!_v) goto check_2;
50266 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50267 }
50268 check_2:
50269
50270 if (argc == 2) {
50271 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50272 }
50273
50274 fail:
50275 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50276 return NULL;
50277 }
50278
50279
50280 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50281 PyObject *resultobj = 0;
50282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50283 wxWindow *arg2 = (wxWindow *) 0 ;
50284 wxGBPosition *arg3 = 0 ;
50285 bool result;
50286 void *argp1 = 0 ;
50287 int res1 = 0 ;
50288 void *argp2 = 0 ;
50289 int res2 = 0 ;
50290 wxGBPosition temp3 ;
50291
50292 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50294 if (!SWIG_IsOK(res1)) {
50295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50296 }
50297 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50299 if (!SWIG_IsOK(res2)) {
50300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50301 }
50302 arg2 = reinterpret_cast< wxWindow * >(argp2);
50303 {
50304 arg3 = &temp3;
50305 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50306 }
50307 {
50308 PyThreadState* __tstate = wxPyBeginAllowThreads();
50309 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50310 wxPyEndAllowThreads(__tstate);
50311 if (PyErr_Occurred()) SWIG_fail;
50312 }
50313 {
50314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50315 }
50316 return resultobj;
50317 fail:
50318 return NULL;
50319 }
50320
50321
50322 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50323 PyObject *resultobj = 0;
50324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50325 wxSizer *arg2 = (wxSizer *) 0 ;
50326 wxGBPosition *arg3 = 0 ;
50327 bool result;
50328 void *argp1 = 0 ;
50329 int res1 = 0 ;
50330 void *argp2 = 0 ;
50331 int res2 = 0 ;
50332 wxGBPosition temp3 ;
50333
50334 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50336 if (!SWIG_IsOK(res1)) {
50337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50338 }
50339 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50340 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50341 if (!SWIG_IsOK(res2)) {
50342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50343 }
50344 arg2 = reinterpret_cast< wxSizer * >(argp2);
50345 {
50346 arg3 = &temp3;
50347 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50348 }
50349 {
50350 PyThreadState* __tstate = wxPyBeginAllowThreads();
50351 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50352 wxPyEndAllowThreads(__tstate);
50353 if (PyErr_Occurred()) SWIG_fail;
50354 }
50355 {
50356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50357 }
50358 return resultobj;
50359 fail:
50360 return NULL;
50361 }
50362
50363
50364 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50365 PyObject *resultobj = 0;
50366 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50367 size_t arg2 ;
50368 wxGBPosition *arg3 = 0 ;
50369 bool result;
50370 void *argp1 = 0 ;
50371 int res1 = 0 ;
50372 size_t val2 ;
50373 int ecode2 = 0 ;
50374 wxGBPosition temp3 ;
50375
50376 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50378 if (!SWIG_IsOK(res1)) {
50379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50380 }
50381 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50382 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50383 if (!SWIG_IsOK(ecode2)) {
50384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50385 }
50386 arg2 = static_cast< size_t >(val2);
50387 {
50388 arg3 = &temp3;
50389 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50390 }
50391 {
50392 PyThreadState* __tstate = wxPyBeginAllowThreads();
50393 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50394 wxPyEndAllowThreads(__tstate);
50395 if (PyErr_Occurred()) SWIG_fail;
50396 }
50397 {
50398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50399 }
50400 return resultobj;
50401 fail:
50402 return NULL;
50403 }
50404
50405
50406 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50407 int argc;
50408 PyObject *argv[4];
50409
50410 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50411 --argc;
50412 if (argc == 3) {
50413 int _v = 0;
50414 {
50415 void *vptr = 0;
50416 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50417 _v = SWIG_CheckState(res);
50418 }
50419 if (!_v) goto check_1;
50420 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50421 }
50422 check_1:
50423
50424 if (argc == 3) {
50425 int _v = 0;
50426 {
50427 void *vptr = 0;
50428 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50429 _v = SWIG_CheckState(res);
50430 }
50431 if (!_v) goto check_2;
50432 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50433 }
50434 check_2:
50435
50436 if (argc == 3) {
50437 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50438 }
50439
50440 fail:
50441 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50447 PyObject *resultobj = 0;
50448 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50449 wxWindow *arg2 = (wxWindow *) 0 ;
50450 wxGBSpan result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 void *argp2 = 0 ;
50454 int res2 = 0 ;
50455
50456 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50460 }
50461 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50462 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50463 if (!SWIG_IsOK(res2)) {
50464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50465 }
50466 arg2 = reinterpret_cast< wxWindow * >(argp2);
50467 {
50468 PyThreadState* __tstate = wxPyBeginAllowThreads();
50469 result = (arg1)->GetItemSpan(arg2);
50470 wxPyEndAllowThreads(__tstate);
50471 if (PyErr_Occurred()) SWIG_fail;
50472 }
50473 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50474 return resultobj;
50475 fail:
50476 return NULL;
50477 }
50478
50479
50480 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50481 PyObject *resultobj = 0;
50482 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50483 wxSizer *arg2 = (wxSizer *) 0 ;
50484 wxGBSpan result;
50485 void *argp1 = 0 ;
50486 int res1 = 0 ;
50487 void *argp2 = 0 ;
50488 int res2 = 0 ;
50489
50490 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50492 if (!SWIG_IsOK(res1)) {
50493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50494 }
50495 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50496 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50497 if (!SWIG_IsOK(res2)) {
50498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50499 }
50500 arg2 = reinterpret_cast< wxSizer * >(argp2);
50501 {
50502 PyThreadState* __tstate = wxPyBeginAllowThreads();
50503 result = (arg1)->GetItemSpan(arg2);
50504 wxPyEndAllowThreads(__tstate);
50505 if (PyErr_Occurred()) SWIG_fail;
50506 }
50507 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50515 PyObject *resultobj = 0;
50516 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50517 size_t arg2 ;
50518 wxGBSpan result;
50519 void *argp1 = 0 ;
50520 int res1 = 0 ;
50521 size_t val2 ;
50522 int ecode2 = 0 ;
50523
50524 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50526 if (!SWIG_IsOK(res1)) {
50527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50528 }
50529 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50530 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50531 if (!SWIG_IsOK(ecode2)) {
50532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50533 }
50534 arg2 = static_cast< size_t >(val2);
50535 {
50536 PyThreadState* __tstate = wxPyBeginAllowThreads();
50537 result = (arg1)->GetItemSpan(arg2);
50538 wxPyEndAllowThreads(__tstate);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50542 return resultobj;
50543 fail:
50544 return NULL;
50545 }
50546
50547
50548 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50549 int argc;
50550 PyObject *argv[3];
50551
50552 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50553 --argc;
50554 if (argc == 2) {
50555 int _v = 0;
50556 {
50557 void *vptr = 0;
50558 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50559 _v = SWIG_CheckState(res);
50560 }
50561 if (!_v) goto check_1;
50562 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50563 }
50564 check_1:
50565
50566 if (argc == 2) {
50567 int _v = 0;
50568 {
50569 void *vptr = 0;
50570 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50571 _v = SWIG_CheckState(res);
50572 }
50573 if (!_v) goto check_2;
50574 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50575 }
50576 check_2:
50577
50578 if (argc == 2) {
50579 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50580 }
50581
50582 fail:
50583 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50589 PyObject *resultobj = 0;
50590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50591 wxWindow *arg2 = (wxWindow *) 0 ;
50592 wxGBSpan *arg3 = 0 ;
50593 bool result;
50594 void *argp1 = 0 ;
50595 int res1 = 0 ;
50596 void *argp2 = 0 ;
50597 int res2 = 0 ;
50598 wxGBSpan temp3 ;
50599
50600 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50606 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50607 if (!SWIG_IsOK(res2)) {
50608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50609 }
50610 arg2 = reinterpret_cast< wxWindow * >(argp2);
50611 {
50612 arg3 = &temp3;
50613 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50614 }
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 {
50622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50623 }
50624 return resultobj;
50625 fail:
50626 return NULL;
50627 }
50628
50629
50630 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50631 PyObject *resultobj = 0;
50632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50633 wxSizer *arg2 = (wxSizer *) 0 ;
50634 wxGBSpan *arg3 = 0 ;
50635 bool result;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 void *argp2 = 0 ;
50639 int res2 = 0 ;
50640 wxGBSpan temp3 ;
50641
50642 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50648 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50649 if (!SWIG_IsOK(res2)) {
50650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50651 }
50652 arg2 = reinterpret_cast< wxSizer * >(argp2);
50653 {
50654 arg3 = &temp3;
50655 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50656 }
50657 {
50658 PyThreadState* __tstate = wxPyBeginAllowThreads();
50659 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50660 wxPyEndAllowThreads(__tstate);
50661 if (PyErr_Occurred()) SWIG_fail;
50662 }
50663 {
50664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50665 }
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50673 PyObject *resultobj = 0;
50674 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50675 size_t arg2 ;
50676 wxGBSpan *arg3 = 0 ;
50677 bool result;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 size_t val2 ;
50681 int ecode2 = 0 ;
50682 wxGBSpan temp3 ;
50683
50684 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50686 if (!SWIG_IsOK(res1)) {
50687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50688 }
50689 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50690 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50691 if (!SWIG_IsOK(ecode2)) {
50692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50693 }
50694 arg2 = static_cast< size_t >(val2);
50695 {
50696 arg3 = &temp3;
50697 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50698 }
50699 {
50700 PyThreadState* __tstate = wxPyBeginAllowThreads();
50701 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 {
50706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50707 }
50708 return resultobj;
50709 fail:
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50715 int argc;
50716 PyObject *argv[4];
50717
50718 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50719 --argc;
50720 if (argc == 3) {
50721 int _v = 0;
50722 {
50723 void *vptr = 0;
50724 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50725 _v = SWIG_CheckState(res);
50726 }
50727 if (!_v) goto check_1;
50728 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50729 }
50730 check_1:
50731
50732 if (argc == 3) {
50733 int _v = 0;
50734 {
50735 void *vptr = 0;
50736 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50737 _v = SWIG_CheckState(res);
50738 }
50739 if (!_v) goto check_2;
50740 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50741 }
50742 check_2:
50743
50744 if (argc == 3) {
50745 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50746 }
50747
50748 fail:
50749 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50750 return NULL;
50751 }
50752
50753
50754 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50755 PyObject *resultobj = 0;
50756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50757 wxWindow *arg2 = (wxWindow *) 0 ;
50758 wxGBSizerItem *result = 0 ;
50759 void *argp1 = 0 ;
50760 int res1 = 0 ;
50761 void *argp2 = 0 ;
50762 int res2 = 0 ;
50763
50764 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50766 if (!SWIG_IsOK(res1)) {
50767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50768 }
50769 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50770 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50771 if (!SWIG_IsOK(res2)) {
50772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50773 }
50774 arg2 = reinterpret_cast< wxWindow * >(argp2);
50775 {
50776 PyThreadState* __tstate = wxPyBeginAllowThreads();
50777 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50778 wxPyEndAllowThreads(__tstate);
50779 if (PyErr_Occurred()) SWIG_fail;
50780 }
50781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50782 return resultobj;
50783 fail:
50784 return NULL;
50785 }
50786
50787
50788 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50789 PyObject *resultobj = 0;
50790 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50791 wxSizer *arg2 = (wxSizer *) 0 ;
50792 wxGBSizerItem *result = 0 ;
50793 void *argp1 = 0 ;
50794 int res1 = 0 ;
50795 void *argp2 = 0 ;
50796 int res2 = 0 ;
50797
50798 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50800 if (!SWIG_IsOK(res1)) {
50801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50802 }
50803 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50804 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50805 if (!SWIG_IsOK(res2)) {
50806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50807 }
50808 arg2 = reinterpret_cast< wxSizer * >(argp2);
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50812 wxPyEndAllowThreads(__tstate);
50813 if (PyErr_Occurred()) SWIG_fail;
50814 }
50815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50816 return resultobj;
50817 fail:
50818 return NULL;
50819 }
50820
50821
50822 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50823 int argc;
50824 PyObject *argv[3];
50825
50826 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50827 --argc;
50828 if (argc == 2) {
50829 int _v = 0;
50830 {
50831 void *vptr = 0;
50832 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50833 _v = SWIG_CheckState(res);
50834 }
50835 if (!_v) goto check_1;
50836 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50837 }
50838 check_1:
50839
50840 if (argc == 2) {
50841 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50842 }
50843
50844 fail:
50845 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50846 return NULL;
50847 }
50848
50849
50850 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50851 PyObject *resultobj = 0;
50852 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50853 wxGBPosition *arg2 = 0 ;
50854 wxGBSizerItem *result = 0 ;
50855 void *argp1 = 0 ;
50856 int res1 = 0 ;
50857 wxGBPosition temp2 ;
50858 PyObject * obj0 = 0 ;
50859 PyObject * obj1 = 0 ;
50860 char * kwnames[] = {
50861 (char *) "self",(char *) "pos", NULL
50862 };
50863
50864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50866 if (!SWIG_IsOK(res1)) {
50867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50868 }
50869 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50870 {
50871 arg2 = &temp2;
50872 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50873 }
50874 {
50875 PyThreadState* __tstate = wxPyBeginAllowThreads();
50876 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50877 wxPyEndAllowThreads(__tstate);
50878 if (PyErr_Occurred()) SWIG_fail;
50879 }
50880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50881 return resultobj;
50882 fail:
50883 return NULL;
50884 }
50885
50886
50887 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50888 PyObject *resultobj = 0;
50889 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50890 wxPoint *arg2 = 0 ;
50891 wxGBSizerItem *result = 0 ;
50892 void *argp1 = 0 ;
50893 int res1 = 0 ;
50894 wxPoint temp2 ;
50895 PyObject * obj0 = 0 ;
50896 PyObject * obj1 = 0 ;
50897 char * kwnames[] = {
50898 (char *) "self",(char *) "pt", NULL
50899 };
50900
50901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50903 if (!SWIG_IsOK(res1)) {
50904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50905 }
50906 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50907 {
50908 arg2 = &temp2;
50909 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50910 }
50911 {
50912 PyThreadState* __tstate = wxPyBeginAllowThreads();
50913 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50914 wxPyEndAllowThreads(__tstate);
50915 if (PyErr_Occurred()) SWIG_fail;
50916 }
50917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50918 return resultobj;
50919 fail:
50920 return NULL;
50921 }
50922
50923
50924 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50925 PyObject *resultobj = 0;
50926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50927 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50928 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50929 bool result;
50930 void *argp1 = 0 ;
50931 int res1 = 0 ;
50932 void *argp2 = 0 ;
50933 int res2 = 0 ;
50934 void *argp3 = 0 ;
50935 int res3 = 0 ;
50936 PyObject * obj0 = 0 ;
50937 PyObject * obj1 = 0 ;
50938 PyObject * obj2 = 0 ;
50939 char * kwnames[] = {
50940 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50941 };
50942
50943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50945 if (!SWIG_IsOK(res1)) {
50946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50947 }
50948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50950 if (!SWIG_IsOK(res2)) {
50951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50952 }
50953 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50954 if (obj2) {
50955 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50956 if (!SWIG_IsOK(res3)) {
50957 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50958 }
50959 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50960 }
50961 {
50962 PyThreadState* __tstate = wxPyBeginAllowThreads();
50963 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50964 wxPyEndAllowThreads(__tstate);
50965 if (PyErr_Occurred()) SWIG_fail;
50966 }
50967 {
50968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50969 }
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50979 wxGBPosition *arg2 = 0 ;
50980 wxGBSpan *arg3 = 0 ;
50981 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50982 bool result;
50983 void *argp1 = 0 ;
50984 int res1 = 0 ;
50985 wxGBPosition temp2 ;
50986 wxGBSpan temp3 ;
50987 void *argp4 = 0 ;
50988 int res4 = 0 ;
50989 PyObject * obj0 = 0 ;
50990 PyObject * obj1 = 0 ;
50991 PyObject * obj2 = 0 ;
50992 PyObject * obj3 = 0 ;
50993 char * kwnames[] = {
50994 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50995 };
50996
50997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50999 if (!SWIG_IsOK(res1)) {
51000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51001 }
51002 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51003 {
51004 arg2 = &temp2;
51005 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51006 }
51007 {
51008 arg3 = &temp3;
51009 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51010 }
51011 if (obj3) {
51012 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51013 if (!SWIG_IsOK(res4)) {
51014 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51015 }
51016 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51017 }
51018 {
51019 PyThreadState* __tstate = wxPyBeginAllowThreads();
51020 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51021 wxPyEndAllowThreads(__tstate);
51022 if (PyErr_Occurred()) SWIG_fail;
51023 }
51024 {
51025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51026 }
51027 return resultobj;
51028 fail:
51029 return NULL;
51030 }
51031
51032
51033 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51034 PyObject *obj;
51035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51036 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51037 return SWIG_Py_Void();
51038 }
51039
51040 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51041 return SWIG_Python_InitShadowInstance(args);
51042 }
51043
51044 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51045 PyObject *resultobj = 0;
51046 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51047 wxRelationship arg2 ;
51048 wxWindow *arg3 = (wxWindow *) 0 ;
51049 wxEdge arg4 ;
51050 int arg5 = (int) 0 ;
51051 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51052 void *argp1 = 0 ;
51053 int res1 = 0 ;
51054 int val2 ;
51055 int ecode2 = 0 ;
51056 void *argp3 = 0 ;
51057 int res3 = 0 ;
51058 int val4 ;
51059 int ecode4 = 0 ;
51060 int val5 ;
51061 int ecode5 = 0 ;
51062 int val6 ;
51063 int ecode6 = 0 ;
51064 PyObject * obj0 = 0 ;
51065 PyObject * obj1 = 0 ;
51066 PyObject * obj2 = 0 ;
51067 PyObject * obj3 = 0 ;
51068 PyObject * obj4 = 0 ;
51069 PyObject * obj5 = 0 ;
51070 char * kwnames[] = {
51071 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51072 };
51073
51074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51076 if (!SWIG_IsOK(res1)) {
51077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51078 }
51079 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51080 ecode2 = SWIG_AsVal_int(obj1, &val2);
51081 if (!SWIG_IsOK(ecode2)) {
51082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51083 }
51084 arg2 = static_cast< wxRelationship >(val2);
51085 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51086 if (!SWIG_IsOK(res3)) {
51087 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51088 }
51089 arg3 = reinterpret_cast< wxWindow * >(argp3);
51090 ecode4 = SWIG_AsVal_int(obj3, &val4);
51091 if (!SWIG_IsOK(ecode4)) {
51092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51093 }
51094 arg4 = static_cast< wxEdge >(val4);
51095 if (obj4) {
51096 ecode5 = SWIG_AsVal_int(obj4, &val5);
51097 if (!SWIG_IsOK(ecode5)) {
51098 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51099 }
51100 arg5 = static_cast< int >(val5);
51101 }
51102 if (obj5) {
51103 ecode6 = SWIG_AsVal_int(obj5, &val6);
51104 if (!SWIG_IsOK(ecode6)) {
51105 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51106 }
51107 arg6 = static_cast< int >(val6);
51108 }
51109 {
51110 PyThreadState* __tstate = wxPyBeginAllowThreads();
51111 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51112 wxPyEndAllowThreads(__tstate);
51113 if (PyErr_Occurred()) SWIG_fail;
51114 }
51115 resultobj = SWIG_Py_Void();
51116 return resultobj;
51117 fail:
51118 return NULL;
51119 }
51120
51121
51122 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51123 PyObject *resultobj = 0;
51124 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51125 wxWindow *arg2 = (wxWindow *) 0 ;
51126 int arg3 = (int) 0 ;
51127 void *argp1 = 0 ;
51128 int res1 = 0 ;
51129 void *argp2 = 0 ;
51130 int res2 = 0 ;
51131 int val3 ;
51132 int ecode3 = 0 ;
51133 PyObject * obj0 = 0 ;
51134 PyObject * obj1 = 0 ;
51135 PyObject * obj2 = 0 ;
51136 char * kwnames[] = {
51137 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51138 };
51139
51140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51142 if (!SWIG_IsOK(res1)) {
51143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51144 }
51145 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51147 if (!SWIG_IsOK(res2)) {
51148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51149 }
51150 arg2 = reinterpret_cast< wxWindow * >(argp2);
51151 if (obj2) {
51152 ecode3 = SWIG_AsVal_int(obj2, &val3);
51153 if (!SWIG_IsOK(ecode3)) {
51154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51155 }
51156 arg3 = static_cast< int >(val3);
51157 }
51158 {
51159 PyThreadState* __tstate = wxPyBeginAllowThreads();
51160 (arg1)->LeftOf(arg2,arg3);
51161 wxPyEndAllowThreads(__tstate);
51162 if (PyErr_Occurred()) SWIG_fail;
51163 }
51164 resultobj = SWIG_Py_Void();
51165 return resultobj;
51166 fail:
51167 return NULL;
51168 }
51169
51170
51171 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51172 PyObject *resultobj = 0;
51173 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51174 wxWindow *arg2 = (wxWindow *) 0 ;
51175 int arg3 = (int) 0 ;
51176 void *argp1 = 0 ;
51177 int res1 = 0 ;
51178 void *argp2 = 0 ;
51179 int res2 = 0 ;
51180 int val3 ;
51181 int ecode3 = 0 ;
51182 PyObject * obj0 = 0 ;
51183 PyObject * obj1 = 0 ;
51184 PyObject * obj2 = 0 ;
51185 char * kwnames[] = {
51186 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51187 };
51188
51189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51191 if (!SWIG_IsOK(res1)) {
51192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51193 }
51194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51196 if (!SWIG_IsOK(res2)) {
51197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51198 }
51199 arg2 = reinterpret_cast< wxWindow * >(argp2);
51200 if (obj2) {
51201 ecode3 = SWIG_AsVal_int(obj2, &val3);
51202 if (!SWIG_IsOK(ecode3)) {
51203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51204 }
51205 arg3 = static_cast< int >(val3);
51206 }
51207 {
51208 PyThreadState* __tstate = wxPyBeginAllowThreads();
51209 (arg1)->RightOf(arg2,arg3);
51210 wxPyEndAllowThreads(__tstate);
51211 if (PyErr_Occurred()) SWIG_fail;
51212 }
51213 resultobj = SWIG_Py_Void();
51214 return resultobj;
51215 fail:
51216 return NULL;
51217 }
51218
51219
51220 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51221 PyObject *resultobj = 0;
51222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51223 wxWindow *arg2 = (wxWindow *) 0 ;
51224 int arg3 = (int) 0 ;
51225 void *argp1 = 0 ;
51226 int res1 = 0 ;
51227 void *argp2 = 0 ;
51228 int res2 = 0 ;
51229 int val3 ;
51230 int ecode3 = 0 ;
51231 PyObject * obj0 = 0 ;
51232 PyObject * obj1 = 0 ;
51233 PyObject * obj2 = 0 ;
51234 char * kwnames[] = {
51235 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51236 };
51237
51238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51240 if (!SWIG_IsOK(res1)) {
51241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51242 }
51243 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51245 if (!SWIG_IsOK(res2)) {
51246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51247 }
51248 arg2 = reinterpret_cast< wxWindow * >(argp2);
51249 if (obj2) {
51250 ecode3 = SWIG_AsVal_int(obj2, &val3);
51251 if (!SWIG_IsOK(ecode3)) {
51252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51253 }
51254 arg3 = static_cast< int >(val3);
51255 }
51256 {
51257 PyThreadState* __tstate = wxPyBeginAllowThreads();
51258 (arg1)->Above(arg2,arg3);
51259 wxPyEndAllowThreads(__tstate);
51260 if (PyErr_Occurred()) SWIG_fail;
51261 }
51262 resultobj = SWIG_Py_Void();
51263 return resultobj;
51264 fail:
51265 return NULL;
51266 }
51267
51268
51269 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51270 PyObject *resultobj = 0;
51271 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51272 wxWindow *arg2 = (wxWindow *) 0 ;
51273 int arg3 = (int) 0 ;
51274 void *argp1 = 0 ;
51275 int res1 = 0 ;
51276 void *argp2 = 0 ;
51277 int res2 = 0 ;
51278 int val3 ;
51279 int ecode3 = 0 ;
51280 PyObject * obj0 = 0 ;
51281 PyObject * obj1 = 0 ;
51282 PyObject * obj2 = 0 ;
51283 char * kwnames[] = {
51284 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51285 };
51286
51287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51289 if (!SWIG_IsOK(res1)) {
51290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51291 }
51292 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51294 if (!SWIG_IsOK(res2)) {
51295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51296 }
51297 arg2 = reinterpret_cast< wxWindow * >(argp2);
51298 if (obj2) {
51299 ecode3 = SWIG_AsVal_int(obj2, &val3);
51300 if (!SWIG_IsOK(ecode3)) {
51301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51302 }
51303 arg3 = static_cast< int >(val3);
51304 }
51305 {
51306 PyThreadState* __tstate = wxPyBeginAllowThreads();
51307 (arg1)->Below(arg2,arg3);
51308 wxPyEndAllowThreads(__tstate);
51309 if (PyErr_Occurred()) SWIG_fail;
51310 }
51311 resultobj = SWIG_Py_Void();
51312 return resultobj;
51313 fail:
51314 return NULL;
51315 }
51316
51317
51318 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51319 PyObject *resultobj = 0;
51320 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51321 wxWindow *arg2 = (wxWindow *) 0 ;
51322 wxEdge arg3 ;
51323 int arg4 = (int) 0 ;
51324 void *argp1 = 0 ;
51325 int res1 = 0 ;
51326 void *argp2 = 0 ;
51327 int res2 = 0 ;
51328 int val3 ;
51329 int ecode3 = 0 ;
51330 int val4 ;
51331 int ecode4 = 0 ;
51332 PyObject * obj0 = 0 ;
51333 PyObject * obj1 = 0 ;
51334 PyObject * obj2 = 0 ;
51335 PyObject * obj3 = 0 ;
51336 char * kwnames[] = {
51337 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51338 };
51339
51340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51342 if (!SWIG_IsOK(res1)) {
51343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51344 }
51345 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51347 if (!SWIG_IsOK(res2)) {
51348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51349 }
51350 arg2 = reinterpret_cast< wxWindow * >(argp2);
51351 ecode3 = SWIG_AsVal_int(obj2, &val3);
51352 if (!SWIG_IsOK(ecode3)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51354 }
51355 arg3 = static_cast< wxEdge >(val3);
51356 if (obj3) {
51357 ecode4 = SWIG_AsVal_int(obj3, &val4);
51358 if (!SWIG_IsOK(ecode4)) {
51359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51360 }
51361 arg4 = static_cast< int >(val4);
51362 }
51363 {
51364 PyThreadState* __tstate = wxPyBeginAllowThreads();
51365 (arg1)->SameAs(arg2,arg3,arg4);
51366 wxPyEndAllowThreads(__tstate);
51367 if (PyErr_Occurred()) SWIG_fail;
51368 }
51369 resultobj = SWIG_Py_Void();
51370 return resultobj;
51371 fail:
51372 return NULL;
51373 }
51374
51375
51376 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51377 PyObject *resultobj = 0;
51378 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51379 wxWindow *arg2 = (wxWindow *) 0 ;
51380 wxEdge arg3 ;
51381 int arg4 ;
51382 void *argp1 = 0 ;
51383 int res1 = 0 ;
51384 void *argp2 = 0 ;
51385 int res2 = 0 ;
51386 int val3 ;
51387 int ecode3 = 0 ;
51388 int val4 ;
51389 int ecode4 = 0 ;
51390 PyObject * obj0 = 0 ;
51391 PyObject * obj1 = 0 ;
51392 PyObject * obj2 = 0 ;
51393 PyObject * obj3 = 0 ;
51394 char * kwnames[] = {
51395 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51396 };
51397
51398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51400 if (!SWIG_IsOK(res1)) {
51401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51402 }
51403 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51405 if (!SWIG_IsOK(res2)) {
51406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51407 }
51408 arg2 = reinterpret_cast< wxWindow * >(argp2);
51409 ecode3 = SWIG_AsVal_int(obj2, &val3);
51410 if (!SWIG_IsOK(ecode3)) {
51411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51412 }
51413 arg3 = static_cast< wxEdge >(val3);
51414 ecode4 = SWIG_AsVal_int(obj3, &val4);
51415 if (!SWIG_IsOK(ecode4)) {
51416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51417 }
51418 arg4 = static_cast< int >(val4);
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 (arg1)->PercentOf(arg2,arg3,arg4);
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 resultobj = SWIG_Py_Void();
51426 return resultobj;
51427 fail:
51428 return NULL;
51429 }
51430
51431
51432 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51433 PyObject *resultobj = 0;
51434 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51435 int arg2 ;
51436 void *argp1 = 0 ;
51437 int res1 = 0 ;
51438 int val2 ;
51439 int ecode2 = 0 ;
51440 PyObject * obj0 = 0 ;
51441 PyObject * obj1 = 0 ;
51442 char * kwnames[] = {
51443 (char *) "self",(char *) "val", NULL
51444 };
51445
51446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51448 if (!SWIG_IsOK(res1)) {
51449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51450 }
51451 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51452 ecode2 = SWIG_AsVal_int(obj1, &val2);
51453 if (!SWIG_IsOK(ecode2)) {
51454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51455 }
51456 arg2 = static_cast< int >(val2);
51457 {
51458 PyThreadState* __tstate = wxPyBeginAllowThreads();
51459 (arg1)->Absolute(arg2);
51460 wxPyEndAllowThreads(__tstate);
51461 if (PyErr_Occurred()) SWIG_fail;
51462 }
51463 resultobj = SWIG_Py_Void();
51464 return resultobj;
51465 fail:
51466 return NULL;
51467 }
51468
51469
51470 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51471 PyObject *resultobj = 0;
51472 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51473 void *argp1 = 0 ;
51474 int res1 = 0 ;
51475 PyObject *swig_obj[1] ;
51476
51477 if (!args) SWIG_fail;
51478 swig_obj[0] = args;
51479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51480 if (!SWIG_IsOK(res1)) {
51481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51482 }
51483 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51484 {
51485 PyThreadState* __tstate = wxPyBeginAllowThreads();
51486 (arg1)->Unconstrained();
51487 wxPyEndAllowThreads(__tstate);
51488 if (PyErr_Occurred()) SWIG_fail;
51489 }
51490 resultobj = SWIG_Py_Void();
51491 return resultobj;
51492 fail:
51493 return NULL;
51494 }
51495
51496
51497 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51498 PyObject *resultobj = 0;
51499 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51500 void *argp1 = 0 ;
51501 int res1 = 0 ;
51502 PyObject *swig_obj[1] ;
51503
51504 if (!args) SWIG_fail;
51505 swig_obj[0] = args;
51506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51507 if (!SWIG_IsOK(res1)) {
51508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51509 }
51510 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51511 {
51512 PyThreadState* __tstate = wxPyBeginAllowThreads();
51513 (arg1)->AsIs();
51514 wxPyEndAllowThreads(__tstate);
51515 if (PyErr_Occurred()) SWIG_fail;
51516 }
51517 resultobj = SWIG_Py_Void();
51518 return resultobj;
51519 fail:
51520 return NULL;
51521 }
51522
51523
51524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51525 PyObject *resultobj = 0;
51526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51527 wxWindow *result = 0 ;
51528 void *argp1 = 0 ;
51529 int res1 = 0 ;
51530 PyObject *swig_obj[1] ;
51531
51532 if (!args) SWIG_fail;
51533 swig_obj[0] = args;
51534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51535 if (!SWIG_IsOK(res1)) {
51536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51537 }
51538 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 result = (wxWindow *)(arg1)->GetOtherWindow();
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 {
51546 resultobj = wxPyMake_wxObject(result, 0);
51547 }
51548 return resultobj;
51549 fail:
51550 return NULL;
51551 }
51552
51553
51554 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51555 PyObject *resultobj = 0;
51556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51557 wxEdge result;
51558 void *argp1 = 0 ;
51559 int res1 = 0 ;
51560 PyObject *swig_obj[1] ;
51561
51562 if (!args) SWIG_fail;
51563 swig_obj[0] = args;
51564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51565 if (!SWIG_IsOK(res1)) {
51566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51567 }
51568 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51569 {
51570 PyThreadState* __tstate = wxPyBeginAllowThreads();
51571 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51572 wxPyEndAllowThreads(__tstate);
51573 if (PyErr_Occurred()) SWIG_fail;
51574 }
51575 resultobj = SWIG_From_int(static_cast< int >(result));
51576 return resultobj;
51577 fail:
51578 return NULL;
51579 }
51580
51581
51582 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51583 PyObject *resultobj = 0;
51584 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51585 wxEdge arg2 ;
51586 void *argp1 = 0 ;
51587 int res1 = 0 ;
51588 int val2 ;
51589 int ecode2 = 0 ;
51590 PyObject * obj0 = 0 ;
51591 PyObject * obj1 = 0 ;
51592 char * kwnames[] = {
51593 (char *) "self",(char *) "which", NULL
51594 };
51595
51596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51598 if (!SWIG_IsOK(res1)) {
51599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51600 }
51601 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51602 ecode2 = SWIG_AsVal_int(obj1, &val2);
51603 if (!SWIG_IsOK(ecode2)) {
51604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51605 }
51606 arg2 = static_cast< wxEdge >(val2);
51607 {
51608 PyThreadState* __tstate = wxPyBeginAllowThreads();
51609 (arg1)->SetEdge(arg2);
51610 wxPyEndAllowThreads(__tstate);
51611 if (PyErr_Occurred()) SWIG_fail;
51612 }
51613 resultobj = SWIG_Py_Void();
51614 return resultobj;
51615 fail:
51616 return NULL;
51617 }
51618
51619
51620 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51621 PyObject *resultobj = 0;
51622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51623 int arg2 ;
51624 void *argp1 = 0 ;
51625 int res1 = 0 ;
51626 int val2 ;
51627 int ecode2 = 0 ;
51628 PyObject * obj0 = 0 ;
51629 PyObject * obj1 = 0 ;
51630 char * kwnames[] = {
51631 (char *) "self",(char *) "v", NULL
51632 };
51633
51634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51636 if (!SWIG_IsOK(res1)) {
51637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51638 }
51639 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51640 ecode2 = SWIG_AsVal_int(obj1, &val2);
51641 if (!SWIG_IsOK(ecode2)) {
51642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51643 }
51644 arg2 = static_cast< int >(val2);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 (arg1)->SetValue(arg2);
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_Py_Void();
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *resultobj = 0;
51660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51661 int result;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 PyObject *swig_obj[1] ;
51665
51666 if (!args) SWIG_fail;
51667 swig_obj[0] = args;
51668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51669 if (!SWIG_IsOK(res1)) {
51670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51671 }
51672 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51673 {
51674 PyThreadState* __tstate = wxPyBeginAllowThreads();
51675 result = (int)(arg1)->GetMargin();
51676 wxPyEndAllowThreads(__tstate);
51677 if (PyErr_Occurred()) SWIG_fail;
51678 }
51679 resultobj = SWIG_From_int(static_cast< int >(result));
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51687 PyObject *resultobj = 0;
51688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51689 int arg2 ;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 int val2 ;
51693 int ecode2 = 0 ;
51694 PyObject * obj0 = 0 ;
51695 PyObject * obj1 = 0 ;
51696 char * kwnames[] = {
51697 (char *) "self",(char *) "m", NULL
51698 };
51699
51700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51702 if (!SWIG_IsOK(res1)) {
51703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51704 }
51705 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51706 ecode2 = SWIG_AsVal_int(obj1, &val2);
51707 if (!SWIG_IsOK(ecode2)) {
51708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51709 }
51710 arg2 = static_cast< int >(val2);
51711 {
51712 PyThreadState* __tstate = wxPyBeginAllowThreads();
51713 (arg1)->SetMargin(arg2);
51714 wxPyEndAllowThreads(__tstate);
51715 if (PyErr_Occurred()) SWIG_fail;
51716 }
51717 resultobj = SWIG_Py_Void();
51718 return resultobj;
51719 fail:
51720 return NULL;
51721 }
51722
51723
51724 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51725 PyObject *resultobj = 0;
51726 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51727 int result;
51728 void *argp1 = 0 ;
51729 int res1 = 0 ;
51730 PyObject *swig_obj[1] ;
51731
51732 if (!args) SWIG_fail;
51733 swig_obj[0] = args;
51734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51735 if (!SWIG_IsOK(res1)) {
51736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51737 }
51738 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51739 {
51740 PyThreadState* __tstate = wxPyBeginAllowThreads();
51741 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51742 wxPyEndAllowThreads(__tstate);
51743 if (PyErr_Occurred()) SWIG_fail;
51744 }
51745 resultobj = SWIG_From_int(static_cast< int >(result));
51746 return resultobj;
51747 fail:
51748 return NULL;
51749 }
51750
51751
51752 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51753 PyObject *resultobj = 0;
51754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51755 int result;
51756 void *argp1 = 0 ;
51757 int res1 = 0 ;
51758 PyObject *swig_obj[1] ;
51759
51760 if (!args) SWIG_fail;
51761 swig_obj[0] = args;
51762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51763 if (!SWIG_IsOK(res1)) {
51764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51765 }
51766 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51767 {
51768 PyThreadState* __tstate = wxPyBeginAllowThreads();
51769 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51770 wxPyEndAllowThreads(__tstate);
51771 if (PyErr_Occurred()) SWIG_fail;
51772 }
51773 resultobj = SWIG_From_int(static_cast< int >(result));
51774 return resultobj;
51775 fail:
51776 return NULL;
51777 }
51778
51779
51780 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51781 PyObject *resultobj = 0;
51782 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51783 int result;
51784 void *argp1 = 0 ;
51785 int res1 = 0 ;
51786 PyObject *swig_obj[1] ;
51787
51788 if (!args) SWIG_fail;
51789 swig_obj[0] = args;
51790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51791 if (!SWIG_IsOK(res1)) {
51792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51793 }
51794 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51795 {
51796 PyThreadState* __tstate = wxPyBeginAllowThreads();
51797 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51798 wxPyEndAllowThreads(__tstate);
51799 if (PyErr_Occurred()) SWIG_fail;
51800 }
51801 resultobj = SWIG_From_int(static_cast< int >(result));
51802 return resultobj;
51803 fail:
51804 return NULL;
51805 }
51806
51807
51808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51809 PyObject *resultobj = 0;
51810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51811 bool result;
51812 void *argp1 = 0 ;
51813 int res1 = 0 ;
51814 PyObject *swig_obj[1] ;
51815
51816 if (!args) SWIG_fail;
51817 swig_obj[0] = args;
51818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51819 if (!SWIG_IsOK(res1)) {
51820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51821 }
51822 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51823 {
51824 PyThreadState* __tstate = wxPyBeginAllowThreads();
51825 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51826 wxPyEndAllowThreads(__tstate);
51827 if (PyErr_Occurred()) SWIG_fail;
51828 }
51829 {
51830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51831 }
51832 return resultobj;
51833 fail:
51834 return NULL;
51835 }
51836
51837
51838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51839 PyObject *resultobj = 0;
51840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51841 bool arg2 ;
51842 void *argp1 = 0 ;
51843 int res1 = 0 ;
51844 bool val2 ;
51845 int ecode2 = 0 ;
51846 PyObject * obj0 = 0 ;
51847 PyObject * obj1 = 0 ;
51848 char * kwnames[] = {
51849 (char *) "self",(char *) "d", NULL
51850 };
51851
51852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51854 if (!SWIG_IsOK(res1)) {
51855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51856 }
51857 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51858 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51859 if (!SWIG_IsOK(ecode2)) {
51860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51861 }
51862 arg2 = static_cast< bool >(val2);
51863 {
51864 PyThreadState* __tstate = wxPyBeginAllowThreads();
51865 (arg1)->SetDone(arg2);
51866 wxPyEndAllowThreads(__tstate);
51867 if (PyErr_Occurred()) SWIG_fail;
51868 }
51869 resultobj = SWIG_Py_Void();
51870 return resultobj;
51871 fail:
51872 return NULL;
51873 }
51874
51875
51876 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51877 PyObject *resultobj = 0;
51878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51879 wxRelationship result;
51880 void *argp1 = 0 ;
51881 int res1 = 0 ;
51882 PyObject *swig_obj[1] ;
51883
51884 if (!args) SWIG_fail;
51885 swig_obj[0] = args;
51886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51887 if (!SWIG_IsOK(res1)) {
51888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51889 }
51890 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51891 {
51892 PyThreadState* __tstate = wxPyBeginAllowThreads();
51893 result = (wxRelationship)(arg1)->GetRelationship();
51894 wxPyEndAllowThreads(__tstate);
51895 if (PyErr_Occurred()) SWIG_fail;
51896 }
51897 resultobj = SWIG_From_int(static_cast< int >(result));
51898 return resultobj;
51899 fail:
51900 return NULL;
51901 }
51902
51903
51904 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51905 PyObject *resultobj = 0;
51906 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51907 wxRelationship arg2 ;
51908 void *argp1 = 0 ;
51909 int res1 = 0 ;
51910 int val2 ;
51911 int ecode2 = 0 ;
51912 PyObject * obj0 = 0 ;
51913 PyObject * obj1 = 0 ;
51914 char * kwnames[] = {
51915 (char *) "self",(char *) "r", NULL
51916 };
51917
51918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51920 if (!SWIG_IsOK(res1)) {
51921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51922 }
51923 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51924 ecode2 = SWIG_AsVal_int(obj1, &val2);
51925 if (!SWIG_IsOK(ecode2)) {
51926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51927 }
51928 arg2 = static_cast< wxRelationship >(val2);
51929 {
51930 PyThreadState* __tstate = wxPyBeginAllowThreads();
51931 (arg1)->SetRelationship(arg2);
51932 wxPyEndAllowThreads(__tstate);
51933 if (PyErr_Occurred()) SWIG_fail;
51934 }
51935 resultobj = SWIG_Py_Void();
51936 return resultobj;
51937 fail:
51938 return NULL;
51939 }
51940
51941
51942 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51943 PyObject *resultobj = 0;
51944 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51945 wxWindow *arg2 = (wxWindow *) 0 ;
51946 bool result;
51947 void *argp1 = 0 ;
51948 int res1 = 0 ;
51949 void *argp2 = 0 ;
51950 int res2 = 0 ;
51951 PyObject * obj0 = 0 ;
51952 PyObject * obj1 = 0 ;
51953 char * kwnames[] = {
51954 (char *) "self",(char *) "otherW", NULL
51955 };
51956
51957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51961 }
51962 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51964 if (!SWIG_IsOK(res2)) {
51965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51966 }
51967 arg2 = reinterpret_cast< wxWindow * >(argp2);
51968 {
51969 PyThreadState* __tstate = wxPyBeginAllowThreads();
51970 result = (bool)(arg1)->ResetIfWin(arg2);
51971 wxPyEndAllowThreads(__tstate);
51972 if (PyErr_Occurred()) SWIG_fail;
51973 }
51974 {
51975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51976 }
51977 return resultobj;
51978 fail:
51979 return NULL;
51980 }
51981
51982
51983 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51984 PyObject *resultobj = 0;
51985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51986 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51987 wxWindow *arg3 = (wxWindow *) 0 ;
51988 bool result;
51989 void *argp1 = 0 ;
51990 int res1 = 0 ;
51991 void *argp2 = 0 ;
51992 int res2 = 0 ;
51993 void *argp3 = 0 ;
51994 int res3 = 0 ;
51995 PyObject * obj0 = 0 ;
51996 PyObject * obj1 = 0 ;
51997 PyObject * obj2 = 0 ;
51998 char * kwnames[] = {
51999 (char *) "self",(char *) "constraints",(char *) "win", NULL
52000 };
52001
52002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52004 if (!SWIG_IsOK(res1)) {
52005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52006 }
52007 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52009 if (!SWIG_IsOK(res2)) {
52010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52011 }
52012 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52013 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52014 if (!SWIG_IsOK(res3)) {
52015 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52016 }
52017 arg3 = reinterpret_cast< wxWindow * >(argp3);
52018 {
52019 PyThreadState* __tstate = wxPyBeginAllowThreads();
52020 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52021 wxPyEndAllowThreads(__tstate);
52022 if (PyErr_Occurred()) SWIG_fail;
52023 }
52024 {
52025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52026 }
52027 return resultobj;
52028 fail:
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52034 PyObject *resultobj = 0;
52035 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52036 wxEdge arg2 ;
52037 wxWindow *arg3 = (wxWindow *) 0 ;
52038 wxWindow *arg4 = (wxWindow *) 0 ;
52039 int result;
52040 void *argp1 = 0 ;
52041 int res1 = 0 ;
52042 int val2 ;
52043 int ecode2 = 0 ;
52044 void *argp3 = 0 ;
52045 int res3 = 0 ;
52046 void *argp4 = 0 ;
52047 int res4 = 0 ;
52048 PyObject * obj0 = 0 ;
52049 PyObject * obj1 = 0 ;
52050 PyObject * obj2 = 0 ;
52051 PyObject * obj3 = 0 ;
52052 char * kwnames[] = {
52053 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52054 };
52055
52056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52058 if (!SWIG_IsOK(res1)) {
52059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52060 }
52061 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52062 ecode2 = SWIG_AsVal_int(obj1, &val2);
52063 if (!SWIG_IsOK(ecode2)) {
52064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52065 }
52066 arg2 = static_cast< wxEdge >(val2);
52067 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52068 if (!SWIG_IsOK(res3)) {
52069 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52070 }
52071 arg3 = reinterpret_cast< wxWindow * >(argp3);
52072 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52073 if (!SWIG_IsOK(res4)) {
52074 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52075 }
52076 arg4 = reinterpret_cast< wxWindow * >(argp4);
52077 {
52078 PyThreadState* __tstate = wxPyBeginAllowThreads();
52079 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52080 wxPyEndAllowThreads(__tstate);
52081 if (PyErr_Occurred()) SWIG_fail;
52082 }
52083 resultobj = SWIG_From_int(static_cast< int >(result));
52084 return resultobj;
52085 fail:
52086 return NULL;
52087 }
52088
52089
52090 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52091 PyObject *obj;
52092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52093 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52094 return SWIG_Py_Void();
52095 }
52096
52097 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52098 PyObject *resultobj = 0;
52099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52100 wxIndividualLayoutConstraint *result = 0 ;
52101 void *argp1 = 0 ;
52102 int res1 = 0 ;
52103 PyObject *swig_obj[1] ;
52104
52105 if (!args) SWIG_fail;
52106 swig_obj[0] = args;
52107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52108 if (!SWIG_IsOK(res1)) {
52109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52110 }
52111 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52112 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52121 PyObject *resultobj = 0;
52122 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52123 wxIndividualLayoutConstraint *result = 0 ;
52124 void *argp1 = 0 ;
52125 int res1 = 0 ;
52126 PyObject *swig_obj[1] ;
52127
52128 if (!args) SWIG_fail;
52129 swig_obj[0] = args;
52130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52131 if (!SWIG_IsOK(res1)) {
52132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52133 }
52134 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52135 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52146 wxIndividualLayoutConstraint *result = 0 ;
52147 void *argp1 = 0 ;
52148 int res1 = 0 ;
52149 PyObject *swig_obj[1] ;
52150
52151 if (!args) SWIG_fail;
52152 swig_obj[0] = args;
52153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52154 if (!SWIG_IsOK(res1)) {
52155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52156 }
52157 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52158 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52167 PyObject *resultobj = 0;
52168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52169 wxIndividualLayoutConstraint *result = 0 ;
52170 void *argp1 = 0 ;
52171 int res1 = 0 ;
52172 PyObject *swig_obj[1] ;
52173
52174 if (!args) SWIG_fail;
52175 swig_obj[0] = args;
52176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52179 }
52180 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52181 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52190 PyObject *resultobj = 0;
52191 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52192 wxIndividualLayoutConstraint *result = 0 ;
52193 void *argp1 = 0 ;
52194 int res1 = 0 ;
52195 PyObject *swig_obj[1] ;
52196
52197 if (!args) SWIG_fail;
52198 swig_obj[0] = args;
52199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52200 if (!SWIG_IsOK(res1)) {
52201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52202 }
52203 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52204 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52206 return resultobj;
52207 fail:
52208 return NULL;
52209 }
52210
52211
52212 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52213 PyObject *resultobj = 0;
52214 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52215 wxIndividualLayoutConstraint *result = 0 ;
52216 void *argp1 = 0 ;
52217 int res1 = 0 ;
52218 PyObject *swig_obj[1] ;
52219
52220 if (!args) SWIG_fail;
52221 swig_obj[0] = args;
52222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52223 if (!SWIG_IsOK(res1)) {
52224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52225 }
52226 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52227 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52229 return resultobj;
52230 fail:
52231 return NULL;
52232 }
52233
52234
52235 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52236 PyObject *resultobj = 0;
52237 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52238 wxIndividualLayoutConstraint *result = 0 ;
52239 void *argp1 = 0 ;
52240 int res1 = 0 ;
52241 PyObject *swig_obj[1] ;
52242
52243 if (!args) SWIG_fail;
52244 swig_obj[0] = args;
52245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52246 if (!SWIG_IsOK(res1)) {
52247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52248 }
52249 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52250 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52252 return resultobj;
52253 fail:
52254 return NULL;
52255 }
52256
52257
52258 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52259 PyObject *resultobj = 0;
52260 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52261 wxIndividualLayoutConstraint *result = 0 ;
52262 void *argp1 = 0 ;
52263 int res1 = 0 ;
52264 PyObject *swig_obj[1] ;
52265
52266 if (!args) SWIG_fail;
52267 swig_obj[0] = args;
52268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52269 if (!SWIG_IsOK(res1)) {
52270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52271 }
52272 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52273 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52275 return resultobj;
52276 fail:
52277 return NULL;
52278 }
52279
52280
52281 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52282 PyObject *resultobj = 0;
52283 wxLayoutConstraints *result = 0 ;
52284
52285 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52286 {
52287 PyThreadState* __tstate = wxPyBeginAllowThreads();
52288 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52289 wxPyEndAllowThreads(__tstate);
52290 if (PyErr_Occurred()) SWIG_fail;
52291 }
52292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52293 return resultobj;
52294 fail:
52295 return NULL;
52296 }
52297
52298
52299 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52300 PyObject *resultobj = 0;
52301 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52302 void *argp1 = 0 ;
52303 int res1 = 0 ;
52304 PyObject *swig_obj[1] ;
52305
52306 if (!args) SWIG_fail;
52307 swig_obj[0] = args;
52308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52309 if (!SWIG_IsOK(res1)) {
52310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52311 }
52312 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52313 {
52314 PyThreadState* __tstate = wxPyBeginAllowThreads();
52315 delete arg1;
52316
52317 wxPyEndAllowThreads(__tstate);
52318 if (PyErr_Occurred()) SWIG_fail;
52319 }
52320 resultobj = SWIG_Py_Void();
52321 return resultobj;
52322 fail:
52323 return NULL;
52324 }
52325
52326
52327 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52328 PyObject *resultobj = 0;
52329 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52330 wxWindow *arg2 = (wxWindow *) 0 ;
52331 int *arg3 = (int *) 0 ;
52332 bool result;
52333 void *argp1 = 0 ;
52334 int res1 = 0 ;
52335 void *argp2 = 0 ;
52336 int res2 = 0 ;
52337 int temp3 ;
52338 int res3 = SWIG_TMPOBJ ;
52339 PyObject * obj0 = 0 ;
52340 PyObject * obj1 = 0 ;
52341 char * kwnames[] = {
52342 (char *) "self",(char *) "win", NULL
52343 };
52344
52345 arg3 = &temp3;
52346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52348 if (!SWIG_IsOK(res1)) {
52349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52350 }
52351 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52353 if (!SWIG_IsOK(res2)) {
52354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52355 }
52356 arg2 = reinterpret_cast< wxWindow * >(argp2);
52357 {
52358 PyThreadState* __tstate = wxPyBeginAllowThreads();
52359 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52360 wxPyEndAllowThreads(__tstate);
52361 if (PyErr_Occurred()) SWIG_fail;
52362 }
52363 {
52364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52365 }
52366 if (SWIG_IsTmpObj(res3)) {
52367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52368 } else {
52369 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52371 }
52372 return resultobj;
52373 fail:
52374 return NULL;
52375 }
52376
52377
52378 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52379 PyObject *resultobj = 0;
52380 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52381 bool result;
52382 void *argp1 = 0 ;
52383 int res1 = 0 ;
52384 PyObject *swig_obj[1] ;
52385
52386 if (!args) SWIG_fail;
52387 swig_obj[0] = args;
52388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52389 if (!SWIG_IsOK(res1)) {
52390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52391 }
52392 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52393 {
52394 PyThreadState* __tstate = wxPyBeginAllowThreads();
52395 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52396 wxPyEndAllowThreads(__tstate);
52397 if (PyErr_Occurred()) SWIG_fail;
52398 }
52399 {
52400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52401 }
52402 return resultobj;
52403 fail:
52404 return NULL;
52405 }
52406
52407
52408 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52409 PyObject *obj;
52410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52411 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52412 return SWIG_Py_Void();
52413 }
52414
52415 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52416 return SWIG_Python_InitShadowInstance(args);
52417 }
52418
52419 static PyMethodDef SwigMethods[] = {
52420 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52421 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52422 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52423 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52424 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52425 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52426 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52427 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52428 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52429 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52430 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52431 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52434 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52435 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52436 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52437 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52441 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52442 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52443 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52445 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52446 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52447 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52448 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52449 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52450 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52451 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52453 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52456 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52459 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52460 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52461 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52462 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52463 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52464 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52465 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52467 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52471 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52472 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52473 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52474 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52475 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52476 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52477 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52480 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52482 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52483 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52485 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52487 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52489 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52491 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52493 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52495 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52496 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52497 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52498 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52499 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52500 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52501 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52502 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52503 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52522 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52523 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52524 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52525 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52526 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52527 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52528 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52529 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52531 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52532 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52533 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52538 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52539 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52540 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52541 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52548 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52552 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52555 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52556 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52557 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52558 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52560 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52561 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52562 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52564 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52565 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52566 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52567 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52572 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52573 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52574 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52575 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52576 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52577 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52580 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52581 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52582 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52584 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52585 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52587 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52588 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52589 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52590 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52591 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52592 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52593 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52594 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52595 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52596 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52597 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52602 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52608 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52609 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52610 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52611 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52613 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52616 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52618 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52621 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52622 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52623 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52626 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52627 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52628 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52632 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52633 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52634 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52638 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52643 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52644 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52645 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52646 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52647 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52648 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52649 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52655 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52656 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52658 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52659 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52660 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52666 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52667 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52669 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52670 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52671 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52672 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52673 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52674 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52675 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52676 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52678 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52679 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52680 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52681 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52682 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52683 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52684 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52685 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52687 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52696 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52708 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52709 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52724 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52725 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52726 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52727 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52730 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52732 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52734 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52736 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52738 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52741 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52742 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52743 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52744 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52746 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52763 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52764 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52770 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52771 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52772 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52773 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52774 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52775 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52776 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52777 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52778 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52779 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52780 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52781 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52782 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52783 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52784 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52785 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52786 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52787 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52788 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52789 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52790 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52791 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52792 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52793 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52794 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52795 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52796 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52797 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52798 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52799 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52800 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52801 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52802 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52803 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52804 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52806 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52807 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52808 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52809 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52812 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52816 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52820 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52821 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52822 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52823 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52825 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52826 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52828 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52830 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52832 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52834 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52835 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52836 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52838 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52839 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52841 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52842 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52843 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52845 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52846 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52847 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52849 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52851 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52852 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52853 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52855 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52857 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52858 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52860 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52861 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52862 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52864 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52865 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52866 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52867 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52868 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52870 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52871 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52874 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52875 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52877 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52878 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52881 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52882 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52884 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52890 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52891 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52892 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52893 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52894 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52895 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52896 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52897 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52898 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52899 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52900 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52901 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52902 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52903 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52904 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52905 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52906 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52907 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52908 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52909 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52910 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52911 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52912 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52913 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52915 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52916 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52917 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52918 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52919 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52920 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52921 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52922 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52923 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52924 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52925 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52926 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52927 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52928 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52929 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52930 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52931 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52932 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52933 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52934 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52935 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52936 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52937 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52938 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52939 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52940 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52941 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52942 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52943 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52944 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52945 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52946 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52948 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52949 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52951 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52952 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52953 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52954 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52956 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52957 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52958 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52959 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52960 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52961 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52962 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52963 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52964 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52965 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52966 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52967 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52968 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52969 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52970 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52971 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52972 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52973 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52974 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52975 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52976 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52977 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52978 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52979 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52980 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52981 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52982 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52983 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52984 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52985 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52986 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52987 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52988 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52989 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52990 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52991 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52994 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52995 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52998 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52999 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53000 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53001 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53002 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53003 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53005 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53006 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53009 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53010 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53012 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53015 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53016 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53018 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53019 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53020 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53022 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53024 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53025 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53027 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53028 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53031 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53032 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53033 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53035 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53036 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53038 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53039 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53040 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53041 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53042 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53045 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53047 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53049 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53050 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53051 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53054 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53055 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53056 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53058 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53059 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53060 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53062 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53063 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53064 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53065 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53066 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53067 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53069 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53070 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53071 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53072 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53073 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53074 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53075 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53076 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53082 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53084 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53086 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53087 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53089 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53090 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53093 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53094 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53095 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53096 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53097 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53098 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53101 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53102 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53103 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53106 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53107 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53109 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53110 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53112 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53114 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53117 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53119 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53120 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53122 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53123 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53124 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53126 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53127 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53128 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53130 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53132 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53133 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53134 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53136 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53138 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53140 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53141 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53143 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53145 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53149 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53151 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53152 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53153 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53155 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53157 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53158 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53159 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53160 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53162 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53164 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53166 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53168 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53169 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53171 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53172 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53173 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53174 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53175 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53176 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53177 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53178 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53180 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53182 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53184 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53186 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53188 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53190 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53191 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53192 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53193 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53194 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53195 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53201 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53202 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53203 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53204 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53205 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53206 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53207 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53209 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53211 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53212 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53214 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53215 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53216 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53217 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53219 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53220 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53221 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53222 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53224 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53225 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53227 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53228 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53231 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53233 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53234 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53235 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53236 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53237 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53239 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53240 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53241 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53242 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53244 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53245 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53246 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53247 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53248 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53249 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53250 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53251 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53252 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53253 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53255 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53258 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53259 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53260 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53262 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53264 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53266 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53268 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53269 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53279 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53280 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53284 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53285 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53286 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53287 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53288 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53289 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53290 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53291 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53292 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53293 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53294 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53295 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53296 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53297 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53298 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53300 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53301 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53304 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53305 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53310 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53311 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53314 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53315 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53316 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53317 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53320 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53321 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53322 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53324 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53326 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53327 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53328 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53330 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53332 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53334 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53337 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53338 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53339 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53340 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53341 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53342 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53343 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53349 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53350 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53351 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53352 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53358 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53364 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53365 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53366 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53367 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53368 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53370 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53380 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53381 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53382 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53383 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53386 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53387 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53388 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53389 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53391 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53392 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53396 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53402 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53403 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53404 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53405 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53407 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53408 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53410 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53413 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53415 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53416 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53417 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53426 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53430 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53432 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53443 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53444 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53445 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53446 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53449 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53452 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53454 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53457 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53459 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53460 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53463 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53465 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53466 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53467 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53468 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53469 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53474 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53475 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53476 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53478 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53479 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53480 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53482 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53484 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53485 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53486 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53488 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53489 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53492 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53499 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53506 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53514 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53517 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53518 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53531 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53533 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53535 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53536 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53538 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53540 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53541 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53543 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53544 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53545 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53549 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53568 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53569 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53571 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53573 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53574 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53575 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53577 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53578 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53581 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53582 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53584 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53585 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53587 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53590 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53591 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53593 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53595 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53597 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53598 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53600 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53601 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53604 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53606 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53608 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53610 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53613 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53615 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53616 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53617 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53619 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53620 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53621 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53623 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53626 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53628 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53629 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53633 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53637 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53638 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53640 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53644 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53646 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53648 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53649 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53650 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53651 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53655 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53656 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53657 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53658 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53660 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53661 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53666 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53667 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53668 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53669 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53670 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53672 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53674 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53676 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53677 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53679 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53681 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53684 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53685 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53686 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53688 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53689 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53690 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53704 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53705 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53706 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53707 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53708 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53709 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53715 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53716 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53720 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53721 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53723 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53724 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53726 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53728 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53729 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53731 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53732 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53733 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53739 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53740 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53741 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53742 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53743 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53744 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53751 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53753 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53754 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53755 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53756 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53757 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53758 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53760 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53764 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53765 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53766 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53767 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53768 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53769 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53770 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53772 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53773 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53774 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53780 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53781 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53782 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53784 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53785 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53786 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53792 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53793 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53794 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53795 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53796 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53800 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53801 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53806 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53807 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53809 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53810 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53815 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53817 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53818 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53819 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53820 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53821 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53826 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53827 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53836 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53837 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53838 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53839 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53842 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53844 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53845 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53846 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53847 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53849 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53854 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53855 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53856 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53857 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53858 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53859 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53860 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53861 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53862 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53863 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53864 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53866 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53867 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53868 { NULL, NULL, 0, NULL }
53869 };
53870
53871
53872 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53873
53874 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53875 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53876 }
53877 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53878 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53879 }
53880 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53881 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53882 }
53883 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53884 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53885 }
53886 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53887 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53888 }
53889 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53890 return (void *)((wxSizer *) ((wxGridSizer *) x));
53891 }
53892 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53893 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53894 }
53895 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53896 return (void *)((wxSizer *) ((wxPySizer *) x));
53897 }
53898 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53899 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53900 }
53901 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53902 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53903 }
53904 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53906 }
53907 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53909 }
53910 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53912 }
53913 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53915 }
53916 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53917 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53918 }
53919 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53920 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53921 }
53922 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53923 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53924 }
53925 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53926 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53927 }
53928 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53929 return (void *)((wxEvent *) ((wxPyEvent *) x));
53930 }
53931 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53932 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53933 }
53934 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53935 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53936 }
53937 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53938 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53939 }
53940 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53941 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53942 }
53943 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53944 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53945 }
53946 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53947 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53948 }
53949 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53950 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53951 }
53952 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53953 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53954 }
53955 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53956 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53957 }
53958 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53959 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53960 }
53961 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53962 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53963 }
53964 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53965 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53966 }
53967 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53968 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53969 }
53970 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53971 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53972 }
53973 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53974 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53975 }
53976 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53977 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53978 }
53979 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53980 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53981 }
53982 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53983 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53984 }
53985 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53986 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53987 }
53988 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53989 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53990 }
53991 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53992 return (void *)((wxEvent *) ((wxShowEvent *) x));
53993 }
53994 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53995 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53996 }
53997 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53998 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53999 }
54000 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54001 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54002 }
54003 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54004 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54005 }
54006 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54007 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54008 }
54009 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54010 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54011 }
54012 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54013 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54014 }
54015 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54016 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54017 }
54018 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54019 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54020 }
54021 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54022 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54023 }
54024 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54025 return (void *)((wxControl *) ((wxControlWithItems *) x));
54026 }
54027 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54028 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54029 }
54030 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54031 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54032 }
54033 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54034 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54035 }
54036 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54037 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54038 }
54039 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54040 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54041 }
54042 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54043 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54044 }
54045 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54046 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54047 }
54048 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54049 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54050 }
54051 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54052 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54053 }
54054 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54055 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54056 }
54057 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54058 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54059 }
54060 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54061 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54062 }
54063 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54064 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54065 }
54066 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54067 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54068 }
54069 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54070 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54071 }
54072 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54073 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54074 }
54075 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54076 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54077 }
54078 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54079 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54080 }
54081 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54082 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54083 }
54084 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54085 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54086 }
54087 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54088 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54089 }
54090 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54091 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54092 }
54093 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54094 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54095 }
54096 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54097 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54098 }
54099 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54100 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54101 }
54102 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54103 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54104 }
54105 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54106 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54107 }
54108 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54109 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54110 }
54111 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54112 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54113 }
54114 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54115 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54116 }
54117 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54119 }
54120 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54122 }
54123 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) ((wxSizerItem *) x));
54125 }
54126 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54128 }
54129 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54131 }
54132 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54134 }
54135 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54137 }
54138 static void *_p_wxSizerTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) ((wxSizer *) x));
54140 }
54141 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54143 }
54144 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54146 }
54147 static void *_p_wxEventTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) ((wxEvent *) x));
54149 }
54150 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54152 }
54153 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54155 }
54156 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54158 }
54159 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54161 }
54162 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54164 }
54165 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54167 }
54168 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54170 }
54171 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54173 }
54174 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54176 }
54177 static void *_p_wxControlTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54179 }
54180 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54182 }
54183 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) ((wxFSFile *) x));
54185 }
54186 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54188 }
54189 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54191 }
54192 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54194 }
54195 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54197 }
54198 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) ((wxMenuItem *) x));
54200 }
54201 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54203 }
54204 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54206 }
54207 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54209 }
54210 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54212 }
54213 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54215 }
54216 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54218 }
54219 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54221 }
54222 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54224 }
54225 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54227 }
54228 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54230 }
54231 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54233 }
54234 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54236 }
54237 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54239 }
54240 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54242 }
54243 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54245 }
54246 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54248 }
54249 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54251 }
54252 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54254 }
54255 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54257 }
54258 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) ((wxImageHandler *) x));
54260 }
54261 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54263 }
54264 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54266 }
54267 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) ((wxEvtHandler *) x));
54269 }
54270 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54272 }
54273 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54275 }
54276 static void *_p_wxImageTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) ((wxImage *) x));
54278 }
54279 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54281 }
54282 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54284 }
54285 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54287 }
54288 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54290 }
54291 static void *_p_wxWindowTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54293 }
54294 static void *_p_wxMenuTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54296 }
54297 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54299 }
54300 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) ((wxFileSystem *) x));
54302 }
54303 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54304 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54305 }
54306 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54307 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54308 }
54309 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54310 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54311 }
54312 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54313 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54314 }
54315 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54316 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54317 }
54318 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54319 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54320 }
54321 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54322 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54323 }
54324 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54325 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54326 }
54327 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54328 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54329 }
54330 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54331 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54332 }
54333 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54335 }
54336 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54337 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54338 }
54339 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54340 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54341 }
54342 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54343 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54344 }
54345 static void *_p_wxControlTo_p_wxWindow(void *x) {
54346 return (void *)((wxWindow *) ((wxControl *) x));
54347 }
54348 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54349 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54350 }
54351 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54352 return (void *)((wxWindow *) ((wxMenuBar *) x));
54353 }
54354 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54355 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54356 }
54357 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54358 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54359 }
54360 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54361 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54362 }
54363 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54364 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54365 }
54366 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54367 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54368 }
54369 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54370 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54371 }
54372 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54373 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54374 }
54375 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54376 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54377 }
54378 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54379 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54380 }
54381 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54382 return (void *)((wxValidator *) ((wxPyValidator *) x));
54383 }
54384 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54386 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};
54387 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54513
54514 static swig_type_info *swig_type_initial[] = {
54515 &_swigt__p_buffer,
54516 &_swigt__p_char,
54517 &_swigt__p_form_ops_t,
54518 &_swigt__p_int,
54519 &_swigt__p_long,
54520 &_swigt__p_unsigned_char,
54521 &_swigt__p_unsigned_int,
54522 &_swigt__p_unsigned_long,
54523 &_swigt__p_wxANIHandler,
54524 &_swigt__p_wxAcceleratorEntry,
54525 &_swigt__p_wxAcceleratorTable,
54526 &_swigt__p_wxActivateEvent,
54527 &_swigt__p_wxAppTraits,
54528 &_swigt__p_wxArrayString,
54529 &_swigt__p_wxBMPHandler,
54530 &_swigt__p_wxBitmap,
54531 &_swigt__p_wxBoxSizer,
54532 &_swigt__p_wxButton,
54533 &_swigt__p_wxCURHandler,
54534 &_swigt__p_wxCaret,
54535 &_swigt__p_wxChildFocusEvent,
54536 &_swigt__p_wxCloseEvent,
54537 &_swigt__p_wxColour,
54538 &_swigt__p_wxCommandEvent,
54539 &_swigt__p_wxContextMenuEvent,
54540 &_swigt__p_wxControl,
54541 &_swigt__p_wxControlWithItems,
54542 &_swigt__p_wxCursor,
54543 &_swigt__p_wxDC,
54544 &_swigt__p_wxDateEvent,
54545 &_swigt__p_wxDateTime,
54546 &_swigt__p_wxDisplayChangedEvent,
54547 &_swigt__p_wxDropFilesEvent,
54548 &_swigt__p_wxDuplexMode,
54549 &_swigt__p_wxEraseEvent,
54550 &_swigt__p_wxEvent,
54551 &_swigt__p_wxEventLoop,
54552 &_swigt__p_wxEventLoopActivator,
54553 &_swigt__p_wxEvtHandler,
54554 &_swigt__p_wxFSFile,
54555 &_swigt__p_wxFileSystem,
54556 &_swigt__p_wxFileSystemHandler,
54557 &_swigt__p_wxFlexGridSizer,
54558 &_swigt__p_wxFocusEvent,
54559 &_swigt__p_wxFont,
54560 &_swigt__p_wxFrame,
54561 &_swigt__p_wxGBPosition,
54562 &_swigt__p_wxGBSizerItem,
54563 &_swigt__p_wxGBSpan,
54564 &_swigt__p_wxGIFHandler,
54565 &_swigt__p_wxGridBagSizer,
54566 &_swigt__p_wxGridSizer,
54567 &_swigt__p_wxICOHandler,
54568 &_swigt__p_wxIconizeEvent,
54569 &_swigt__p_wxIdleEvent,
54570 &_swigt__p_wxImage,
54571 &_swigt__p_wxImageHandler,
54572 &_swigt__p_wxImageHistogram,
54573 &_swigt__p_wxImage_HSVValue,
54574 &_swigt__p_wxImage_RGBValue,
54575 &_swigt__p_wxIndividualLayoutConstraint,
54576 &_swigt__p_wxInitDialogEvent,
54577 &_swigt__p_wxInputStream,
54578 &_swigt__p_wxInternetFSHandler,
54579 &_swigt__p_wxItemContainer,
54580 &_swigt__p_wxJPEGHandler,
54581 &_swigt__p_wxKeyEvent,
54582 &_swigt__p_wxLayoutConstraints,
54583 &_swigt__p_wxMaximizeEvent,
54584 &_swigt__p_wxMemoryFSHandler,
54585 &_swigt__p_wxMenu,
54586 &_swigt__p_wxMenuBar,
54587 &_swigt__p_wxMenuBarBase,
54588 &_swigt__p_wxMenuEvent,
54589 &_swigt__p_wxMenuItem,
54590 &_swigt__p_wxMouseCaptureChangedEvent,
54591 &_swigt__p_wxMouseEvent,
54592 &_swigt__p_wxMoveEvent,
54593 &_swigt__p_wxNavigationKeyEvent,
54594 &_swigt__p_wxNcPaintEvent,
54595 &_swigt__p_wxNotifyEvent,
54596 &_swigt__p_wxObject,
54597 &_swigt__p_wxOutputStream,
54598 &_swigt__p_wxPCXHandler,
54599 &_swigt__p_wxPNGHandler,
54600 &_swigt__p_wxPNMHandler,
54601 &_swigt__p_wxPaintEvent,
54602 &_swigt__p_wxPaletteChangedEvent,
54603 &_swigt__p_wxPaperSize,
54604 &_swigt__p_wxPoint,
54605 &_swigt__p_wxPoint2D,
54606 &_swigt__p_wxPropagateOnce,
54607 &_swigt__p_wxPropagationDisabler,
54608 &_swigt__p_wxPyApp,
54609 &_swigt__p_wxPyCommandEvent,
54610 &_swigt__p_wxPyDropTarget,
54611 &_swigt__p_wxPyEvent,
54612 &_swigt__p_wxPyFileSystemHandler,
54613 &_swigt__p_wxPyImageHandler,
54614 &_swigt__p_wxPyInputStream,
54615 &_swigt__p_wxPySizer,
54616 &_swigt__p_wxPyValidator,
54617 &_swigt__p_wxQuantize,
54618 &_swigt__p_wxQueryNewPaletteEvent,
54619 &_swigt__p_wxRealPoint,
54620 &_swigt__p_wxRect,
54621 &_swigt__p_wxRegion,
54622 &_swigt__p_wxScrollEvent,
54623 &_swigt__p_wxScrollWinEvent,
54624 &_swigt__p_wxSetCursorEvent,
54625 &_swigt__p_wxShowEvent,
54626 &_swigt__p_wxSize,
54627 &_swigt__p_wxSizeEvent,
54628 &_swigt__p_wxSizer,
54629 &_swigt__p_wxSizerItem,
54630 &_swigt__p_wxStaticBox,
54631 &_swigt__p_wxStaticBoxSizer,
54632 &_swigt__p_wxStdDialogButtonSizer,
54633 &_swigt__p_wxSysColourChangedEvent,
54634 &_swigt__p_wxTIFFHandler,
54635 &_swigt__p_wxToolTip,
54636 &_swigt__p_wxUpdateUIEvent,
54637 &_swigt__p_wxValidator,
54638 &_swigt__p_wxVisualAttributes,
54639 &_swigt__p_wxWindow,
54640 &_swigt__p_wxWindowCreateEvent,
54641 &_swigt__p_wxWindowDestroyEvent,
54642 &_swigt__p_wxXPMHandler,
54643 &_swigt__p_wxZipFSHandler,
54644 };
54645
54646 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54660 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}};
54661 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54662 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}};
54663 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54664 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}};
54665 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54671 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}};
54672 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54684 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}};
54685 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54686 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54687 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}};
54688 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}};
54689 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54690 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54691 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54692 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54697 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}};
54698 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}};
54699 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54702 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}};
54703 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54710 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}};
54711 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54712 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54713 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54714 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54715 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54716 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54717 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54718 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54719 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54721 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54722 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54733 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54734 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54736 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54737 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54738 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54739 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54740 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54741 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54746 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54747 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54748 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54749 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54750 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54751 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54752 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54753 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54754 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54755 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54757 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54758 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54759 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}};
54760 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}};
54761 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54762 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54763 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54764 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54765 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54768 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}};
54769 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54770 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}};
54771 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54775
54776 static swig_cast_info *swig_cast_initial[] = {
54777 _swigc__p_buffer,
54778 _swigc__p_char,
54779 _swigc__p_form_ops_t,
54780 _swigc__p_int,
54781 _swigc__p_long,
54782 _swigc__p_unsigned_char,
54783 _swigc__p_unsigned_int,
54784 _swigc__p_unsigned_long,
54785 _swigc__p_wxANIHandler,
54786 _swigc__p_wxAcceleratorEntry,
54787 _swigc__p_wxAcceleratorTable,
54788 _swigc__p_wxActivateEvent,
54789 _swigc__p_wxAppTraits,
54790 _swigc__p_wxArrayString,
54791 _swigc__p_wxBMPHandler,
54792 _swigc__p_wxBitmap,
54793 _swigc__p_wxBoxSizer,
54794 _swigc__p_wxButton,
54795 _swigc__p_wxCURHandler,
54796 _swigc__p_wxCaret,
54797 _swigc__p_wxChildFocusEvent,
54798 _swigc__p_wxCloseEvent,
54799 _swigc__p_wxColour,
54800 _swigc__p_wxCommandEvent,
54801 _swigc__p_wxContextMenuEvent,
54802 _swigc__p_wxControl,
54803 _swigc__p_wxControlWithItems,
54804 _swigc__p_wxCursor,
54805 _swigc__p_wxDC,
54806 _swigc__p_wxDateEvent,
54807 _swigc__p_wxDateTime,
54808 _swigc__p_wxDisplayChangedEvent,
54809 _swigc__p_wxDropFilesEvent,
54810 _swigc__p_wxDuplexMode,
54811 _swigc__p_wxEraseEvent,
54812 _swigc__p_wxEvent,
54813 _swigc__p_wxEventLoop,
54814 _swigc__p_wxEventLoopActivator,
54815 _swigc__p_wxEvtHandler,
54816 _swigc__p_wxFSFile,
54817 _swigc__p_wxFileSystem,
54818 _swigc__p_wxFileSystemHandler,
54819 _swigc__p_wxFlexGridSizer,
54820 _swigc__p_wxFocusEvent,
54821 _swigc__p_wxFont,
54822 _swigc__p_wxFrame,
54823 _swigc__p_wxGBPosition,
54824 _swigc__p_wxGBSizerItem,
54825 _swigc__p_wxGBSpan,
54826 _swigc__p_wxGIFHandler,
54827 _swigc__p_wxGridBagSizer,
54828 _swigc__p_wxGridSizer,
54829 _swigc__p_wxICOHandler,
54830 _swigc__p_wxIconizeEvent,
54831 _swigc__p_wxIdleEvent,
54832 _swigc__p_wxImage,
54833 _swigc__p_wxImageHandler,
54834 _swigc__p_wxImageHistogram,
54835 _swigc__p_wxImage_HSVValue,
54836 _swigc__p_wxImage_RGBValue,
54837 _swigc__p_wxIndividualLayoutConstraint,
54838 _swigc__p_wxInitDialogEvent,
54839 _swigc__p_wxInputStream,
54840 _swigc__p_wxInternetFSHandler,
54841 _swigc__p_wxItemContainer,
54842 _swigc__p_wxJPEGHandler,
54843 _swigc__p_wxKeyEvent,
54844 _swigc__p_wxLayoutConstraints,
54845 _swigc__p_wxMaximizeEvent,
54846 _swigc__p_wxMemoryFSHandler,
54847 _swigc__p_wxMenu,
54848 _swigc__p_wxMenuBar,
54849 _swigc__p_wxMenuBarBase,
54850 _swigc__p_wxMenuEvent,
54851 _swigc__p_wxMenuItem,
54852 _swigc__p_wxMouseCaptureChangedEvent,
54853 _swigc__p_wxMouseEvent,
54854 _swigc__p_wxMoveEvent,
54855 _swigc__p_wxNavigationKeyEvent,
54856 _swigc__p_wxNcPaintEvent,
54857 _swigc__p_wxNotifyEvent,
54858 _swigc__p_wxObject,
54859 _swigc__p_wxOutputStream,
54860 _swigc__p_wxPCXHandler,
54861 _swigc__p_wxPNGHandler,
54862 _swigc__p_wxPNMHandler,
54863 _swigc__p_wxPaintEvent,
54864 _swigc__p_wxPaletteChangedEvent,
54865 _swigc__p_wxPaperSize,
54866 _swigc__p_wxPoint,
54867 _swigc__p_wxPoint2D,
54868 _swigc__p_wxPropagateOnce,
54869 _swigc__p_wxPropagationDisabler,
54870 _swigc__p_wxPyApp,
54871 _swigc__p_wxPyCommandEvent,
54872 _swigc__p_wxPyDropTarget,
54873 _swigc__p_wxPyEvent,
54874 _swigc__p_wxPyFileSystemHandler,
54875 _swigc__p_wxPyImageHandler,
54876 _swigc__p_wxPyInputStream,
54877 _swigc__p_wxPySizer,
54878 _swigc__p_wxPyValidator,
54879 _swigc__p_wxQuantize,
54880 _swigc__p_wxQueryNewPaletteEvent,
54881 _swigc__p_wxRealPoint,
54882 _swigc__p_wxRect,
54883 _swigc__p_wxRegion,
54884 _swigc__p_wxScrollEvent,
54885 _swigc__p_wxScrollWinEvent,
54886 _swigc__p_wxSetCursorEvent,
54887 _swigc__p_wxShowEvent,
54888 _swigc__p_wxSize,
54889 _swigc__p_wxSizeEvent,
54890 _swigc__p_wxSizer,
54891 _swigc__p_wxSizerItem,
54892 _swigc__p_wxStaticBox,
54893 _swigc__p_wxStaticBoxSizer,
54894 _swigc__p_wxStdDialogButtonSizer,
54895 _swigc__p_wxSysColourChangedEvent,
54896 _swigc__p_wxTIFFHandler,
54897 _swigc__p_wxToolTip,
54898 _swigc__p_wxUpdateUIEvent,
54899 _swigc__p_wxValidator,
54900 _swigc__p_wxVisualAttributes,
54901 _swigc__p_wxWindow,
54902 _swigc__p_wxWindowCreateEvent,
54903 _swigc__p_wxWindowDestroyEvent,
54904 _swigc__p_wxXPMHandler,
54905 _swigc__p_wxZipFSHandler,
54906 };
54907
54908
54909 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54910
54911 static swig_const_info swig_const_table[] = {
54912 {0, 0, 0, 0.0, 0, 0}};
54913
54914 #ifdef __cplusplus
54915 }
54916 #endif
54917 /* -----------------------------------------------------------------------------
54918 * Type initialization:
54919 * This problem is tough by the requirement that no dynamic
54920 * memory is used. Also, since swig_type_info structures store pointers to
54921 * swig_cast_info structures and swig_cast_info structures store pointers back
54922 * to swig_type_info structures, we need some lookup code at initialization.
54923 * The idea is that swig generates all the structures that are needed.
54924 * The runtime then collects these partially filled structures.
54925 * The SWIG_InitializeModule function takes these initial arrays out of
54926 * swig_module, and does all the lookup, filling in the swig_module.types
54927 * array with the correct data and linking the correct swig_cast_info
54928 * structures together.
54929 *
54930 * The generated swig_type_info structures are assigned staticly to an initial
54931 * array. We just loop though that array, and handle each type individually.
54932 * First we lookup if this type has been already loaded, and if so, use the
54933 * loaded structure instead of the generated one. Then we have to fill in the
54934 * cast linked list. The cast data is initially stored in something like a
54935 * two-dimensional array. Each row corresponds to a type (there are the same
54936 * number of rows as there are in the swig_type_initial array). Each entry in
54937 * a column is one of the swig_cast_info structures for that type.
54938 * The cast_initial array is actually an array of arrays, because each row has
54939 * a variable number of columns. So to actually build the cast linked list,
54940 * we find the array of casts associated with the type, and loop through it
54941 * adding the casts to the list. The one last trick we need to do is making
54942 * sure the type pointer in the swig_cast_info struct is correct.
54943 *
54944 * First off, we lookup the cast->type name to see if it is already loaded.
54945 * There are three cases to handle:
54946 * 1) If the cast->type has already been loaded AND the type we are adding
54947 * casting info to has not been loaded (it is in this module), THEN we
54948 * replace the cast->type pointer with the type pointer that has already
54949 * been loaded.
54950 * 2) If BOTH types (the one we are adding casting info to, and the
54951 * cast->type) are loaded, THEN the cast info has already been loaded by
54952 * the previous module so we just ignore it.
54953 * 3) Finally, if cast->type has not already been loaded, then we add that
54954 * swig_cast_info to the linked list (because the cast->type) pointer will
54955 * be correct.
54956 * ----------------------------------------------------------------------------- */
54957
54958 #ifdef __cplusplus
54959 extern "C" {
54960 #if 0
54961 } /* c-mode */
54962 #endif
54963 #endif
54964
54965 #if 0
54966 #define SWIGRUNTIME_DEBUG
54967 #endif
54968
54969 SWIGRUNTIME void
54970 SWIG_InitializeModule(void *clientdata) {
54971 size_t i;
54972 swig_module_info *module_head;
54973 static int init_run = 0;
54974
54975 clientdata = clientdata;
54976
54977 if (init_run) return;
54978 init_run = 1;
54979
54980 /* Initialize the swig_module */
54981 swig_module.type_initial = swig_type_initial;
54982 swig_module.cast_initial = swig_cast_initial;
54983
54984 /* Try and load any already created modules */
54985 module_head = SWIG_GetModule(clientdata);
54986 if (module_head) {
54987 swig_module.next = module_head->next;
54988 module_head->next = &swig_module;
54989 } else {
54990 /* This is the first module loaded */
54991 swig_module.next = &swig_module;
54992 SWIG_SetModule(clientdata, &swig_module);
54993 }
54994
54995 /* Now work on filling in swig_module.types */
54996 #ifdef SWIGRUNTIME_DEBUG
54997 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54998 #endif
54999 for (i = 0; i < swig_module.size; ++i) {
55000 swig_type_info *type = 0;
55001 swig_type_info *ret;
55002 swig_cast_info *cast;
55003
55004 #ifdef SWIGRUNTIME_DEBUG
55005 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55006 #endif
55007
55008 /* if there is another module already loaded */
55009 if (swig_module.next != &swig_module) {
55010 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55011 }
55012 if (type) {
55013 /* Overwrite clientdata field */
55014 #ifdef SWIGRUNTIME_DEBUG
55015 printf("SWIG_InitializeModule: found type %s\n", type->name);
55016 #endif
55017 if (swig_module.type_initial[i]->clientdata) {
55018 type->clientdata = swig_module.type_initial[i]->clientdata;
55019 #ifdef SWIGRUNTIME_DEBUG
55020 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55021 #endif
55022 }
55023 } else {
55024 type = swig_module.type_initial[i];
55025 }
55026
55027 /* Insert casting types */
55028 cast = swig_module.cast_initial[i];
55029 while (cast->type) {
55030 /* Don't need to add information already in the list */
55031 ret = 0;
55032 #ifdef SWIGRUNTIME_DEBUG
55033 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55034 #endif
55035 if (swig_module.next != &swig_module) {
55036 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55037 #ifdef SWIGRUNTIME_DEBUG
55038 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55039 #endif
55040 }
55041 if (ret) {
55042 if (type == swig_module.type_initial[i]) {
55043 #ifdef SWIGRUNTIME_DEBUG
55044 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55045 #endif
55046 cast->type = ret;
55047 ret = 0;
55048 } else {
55049 /* Check for casting already in the list */
55050 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55051 #ifdef SWIGRUNTIME_DEBUG
55052 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55053 #endif
55054 if (!ocast) ret = 0;
55055 }
55056 }
55057
55058 if (!ret) {
55059 #ifdef SWIGRUNTIME_DEBUG
55060 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55061 #endif
55062 if (type->cast) {
55063 type->cast->prev = cast;
55064 cast->next = type->cast;
55065 }
55066 type->cast = cast;
55067 }
55068 cast++;
55069 }
55070 /* Set entry in modules->types array equal to the type */
55071 swig_module.types[i] = type;
55072 }
55073 swig_module.types[i] = 0;
55074
55075 #ifdef SWIGRUNTIME_DEBUG
55076 printf("**** SWIG_InitializeModule: Cast List ******\n");
55077 for (i = 0; i < swig_module.size; ++i) {
55078 int j = 0;
55079 swig_cast_info *cast = swig_module.cast_initial[i];
55080 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55081 while (cast->type) {
55082 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55083 cast++;
55084 ++j;
55085 }
55086 printf("---- Total casts: %d\n",j);
55087 }
55088 printf("**** SWIG_InitializeModule: Cast List ******\n");
55089 #endif
55090 }
55091
55092 /* This function will propagate the clientdata field of type to
55093 * any new swig_type_info structures that have been added into the list
55094 * of equivalent types. It is like calling
55095 * SWIG_TypeClientData(type, clientdata) a second time.
55096 */
55097 SWIGRUNTIME void
55098 SWIG_PropagateClientData(void) {
55099 size_t i;
55100 swig_cast_info *equiv;
55101 static int init_run = 0;
55102
55103 if (init_run) return;
55104 init_run = 1;
55105
55106 for (i = 0; i < swig_module.size; i++) {
55107 if (swig_module.types[i]->clientdata) {
55108 equiv = swig_module.types[i]->cast;
55109 while (equiv) {
55110 if (!equiv->converter) {
55111 if (equiv->type && !equiv->type->clientdata)
55112 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55113 }
55114 equiv = equiv->next;
55115 }
55116 }
55117 }
55118 }
55119
55120 #ifdef __cplusplus
55121 #if 0
55122 {
55123 /* c-mode */
55124 #endif
55125 }
55126 #endif
55127
55128
55129
55130 #ifdef __cplusplus
55131 extern "C" {
55132 #endif
55133
55134 /* Python-specific SWIG API */
55135 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55136 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55137 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55138
55139 /* -----------------------------------------------------------------------------
55140 * global variable support code.
55141 * ----------------------------------------------------------------------------- */
55142
55143 typedef struct swig_globalvar {
55144 char *name; /* Name of global variable */
55145 PyObject *(*get_attr)(void); /* Return the current value */
55146 int (*set_attr)(PyObject *); /* Set the value */
55147 struct swig_globalvar *next;
55148 } swig_globalvar;
55149
55150 typedef struct swig_varlinkobject {
55151 PyObject_HEAD
55152 swig_globalvar *vars;
55153 } swig_varlinkobject;
55154
55155 SWIGINTERN PyObject *
55156 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55157 return PyString_FromString("<Swig global variables>");
55158 }
55159
55160 SWIGINTERN PyObject *
55161 swig_varlink_str(swig_varlinkobject *v) {
55162 PyObject *str = PyString_FromString("(");
55163 swig_globalvar *var;
55164 for (var = v->vars; var; var=var->next) {
55165 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55166 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55167 }
55168 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55169 return str;
55170 }
55171
55172 SWIGINTERN int
55173 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55174 PyObject *str = swig_varlink_str(v);
55175 fprintf(fp,"Swig global variables ");
55176 fprintf(fp,"%s\n", PyString_AsString(str));
55177 Py_DECREF(str);
55178 return 0;
55179 }
55180
55181 SWIGINTERN void
55182 swig_varlink_dealloc(swig_varlinkobject *v) {
55183 swig_globalvar *var = v->vars;
55184 while (var) {
55185 swig_globalvar *n = var->next;
55186 free(var->name);
55187 free(var);
55188 var = n;
55189 }
55190 }
55191
55192 SWIGINTERN PyObject *
55193 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55194 PyObject *res = NULL;
55195 swig_globalvar *var = v->vars;
55196 while (var) {
55197 if (strcmp(var->name,n) == 0) {
55198 res = (*var->get_attr)();
55199 break;
55200 }
55201 var = var->next;
55202 }
55203 if (res == NULL && !PyErr_Occurred()) {
55204 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55205 }
55206 return res;
55207 }
55208
55209 SWIGINTERN int
55210 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55211 int res = 1;
55212 swig_globalvar *var = v->vars;
55213 while (var) {
55214 if (strcmp(var->name,n) == 0) {
55215 res = (*var->set_attr)(p);
55216 break;
55217 }
55218 var = var->next;
55219 }
55220 if (res == 1 && !PyErr_Occurred()) {
55221 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55222 }
55223 return res;
55224 }
55225
55226 SWIGINTERN PyTypeObject*
55227 swig_varlink_type(void) {
55228 static char varlink__doc__[] = "Swig var link object";
55229 static PyTypeObject varlink_type;
55230 static int type_init = 0;
55231 if (!type_init) {
55232 const PyTypeObject tmp
55233 = {
55234 PyObject_HEAD_INIT(NULL)
55235 0, /* Number of items in variable part (ob_size) */
55236 (char *)"swigvarlink", /* Type name (tp_name) */
55237 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55238 0, /* Itemsize (tp_itemsize) */
55239 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55240 (printfunc) swig_varlink_print, /* Print (tp_print) */
55241 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55242 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55243 0, /* tp_compare */
55244 (reprfunc) swig_varlink_repr, /* tp_repr */
55245 0, /* tp_as_number */
55246 0, /* tp_as_sequence */
55247 0, /* tp_as_mapping */
55248 0, /* tp_hash */
55249 0, /* tp_call */
55250 (reprfunc)swig_varlink_str, /* tp_str */
55251 0, /* tp_getattro */
55252 0, /* tp_setattro */
55253 0, /* tp_as_buffer */
55254 0, /* tp_flags */
55255 varlink__doc__, /* tp_doc */
55256 0, /* tp_traverse */
55257 0, /* tp_clear */
55258 0, /* tp_richcompare */
55259 0, /* tp_weaklistoffset */
55260 #if PY_VERSION_HEX >= 0x02020000
55261 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55262 #endif
55263 #if PY_VERSION_HEX >= 0x02030000
55264 0, /* tp_del */
55265 #endif
55266 #ifdef COUNT_ALLOCS
55267 0,0,0,0 /* tp_alloc -> tp_next */
55268 #endif
55269 };
55270 varlink_type = tmp;
55271 varlink_type.ob_type = &PyType_Type;
55272 type_init = 1;
55273 }
55274 return &varlink_type;
55275 }
55276
55277 /* Create a variable linking object for use later */
55278 SWIGINTERN PyObject *
55279 SWIG_Python_newvarlink(void) {
55280 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55281 if (result) {
55282 result->vars = 0;
55283 }
55284 return ((PyObject*) result);
55285 }
55286
55287 SWIGINTERN void
55288 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55289 swig_varlinkobject *v = (swig_varlinkobject *) p;
55290 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55291 if (gv) {
55292 size_t size = strlen(name)+1;
55293 gv->name = (char *)malloc(size);
55294 if (gv->name) {
55295 strncpy(gv->name,name,size);
55296 gv->get_attr = get_attr;
55297 gv->set_attr = set_attr;
55298 gv->next = v->vars;
55299 }
55300 }
55301 v->vars = gv;
55302 }
55303
55304 SWIGINTERN PyObject *
55305 SWIG_globals() {
55306 static PyObject *_SWIG_globals = 0;
55307 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55308 return _SWIG_globals;
55309 }
55310
55311 /* -----------------------------------------------------------------------------
55312 * constants/methods manipulation
55313 * ----------------------------------------------------------------------------- */
55314
55315 /* Install Constants */
55316 SWIGINTERN void
55317 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55318 PyObject *obj = 0;
55319 size_t i;
55320 for (i = 0; constants[i].type; ++i) {
55321 switch(constants[i].type) {
55322 case SWIG_PY_POINTER:
55323 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55324 break;
55325 case SWIG_PY_BINARY:
55326 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55327 break;
55328 default:
55329 obj = 0;
55330 break;
55331 }
55332 if (obj) {
55333 PyDict_SetItemString(d, constants[i].name, obj);
55334 Py_DECREF(obj);
55335 }
55336 }
55337 }
55338
55339 /* -----------------------------------------------------------------------------*/
55340 /* Fix SwigMethods to carry the callback ptrs when needed */
55341 /* -----------------------------------------------------------------------------*/
55342
55343 SWIGINTERN void
55344 SWIG_Python_FixMethods(PyMethodDef *methods,
55345 swig_const_info *const_table,
55346 swig_type_info **types,
55347 swig_type_info **types_initial) {
55348 size_t i;
55349 for (i = 0; methods[i].ml_name; ++i) {
55350 char *c = methods[i].ml_doc;
55351 if (c && (c = strstr(c, "swig_ptr: "))) {
55352 int j;
55353 swig_const_info *ci = 0;
55354 char *name = c + 10;
55355 for (j = 0; const_table[j].type; ++j) {
55356 if (strncmp(const_table[j].name, name,
55357 strlen(const_table[j].name)) == 0) {
55358 ci = &(const_table[j]);
55359 break;
55360 }
55361 }
55362 if (ci) {
55363 size_t shift = (ci->ptype) - types;
55364 swig_type_info *ty = types_initial[shift];
55365 size_t ldoc = (c - methods[i].ml_doc);
55366 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55367 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55368 if (ndoc) {
55369 char *buff = ndoc;
55370 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55371 if (ptr) {
55372 strncpy(buff, methods[i].ml_doc, ldoc);
55373 buff += ldoc;
55374 strncpy(buff, "swig_ptr: ", 10);
55375 buff += 10;
55376 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55377 methods[i].ml_doc = ndoc;
55378 }
55379 }
55380 }
55381 }
55382 }
55383 }
55384
55385 #ifdef __cplusplus
55386 }
55387 #endif
55388
55389 /* -----------------------------------------------------------------------------*
55390 * Partial Init method
55391 * -----------------------------------------------------------------------------*/
55392
55393 #ifdef __cplusplus
55394 extern "C"
55395 #endif
55396 SWIGEXPORT void SWIG_init(void) {
55397 PyObject *m, *d;
55398
55399 /* Fix SwigMethods to carry the callback ptrs when needed */
55400 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55401
55402 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55403 d = PyModule_GetDict(m);
55404
55405 SWIG_InitializeModule(0);
55406 SWIG_InstallConstants(d,swig_const_table);
55407
55408
55409
55410 #ifndef wxPyUSE_EXPORT
55411 // Make our API structure a CObject so other modules can import it
55412 // from this module.
55413 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55414 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55415 Py_XDECREF(cobj);
55416 #endif
55417
55418 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55419 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55420 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55421 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55422 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55423 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55424 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55425 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55426 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55427 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55428 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55429 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55430 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55431 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55432 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55433 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55434 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55435 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55436 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55437 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55438 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55439 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55440 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55441 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55442 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55443 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55444 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55445 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55446 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55447 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55448 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55449 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55450 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55451 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55452 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55453 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55454 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55455 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55456 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55457 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55458 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55459 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55460 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55461 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55462 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55463 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55464 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55465 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55466 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55467 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55468 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55469 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55470 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55471 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55472 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55473 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55474 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55475 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55476 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55477 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55478 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55479 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55480 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55481 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55482 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55483 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55484 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55485 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55486 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55487 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55488 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55489 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55490 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55491 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55492 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55493 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55494 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55495 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55496 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55497 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55498 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55499 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55500 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55501 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55502 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55503 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55504 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55505 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55506 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55507 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55508 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55509 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55510 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55511 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55512 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55513 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55514 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55515 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55516 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55517 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55518 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55519 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55520 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55521 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55522 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55523 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55524 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55525 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55526 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55527 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55528 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55529 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55530 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55531 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55532 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55533 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55534 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55535 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55536 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55537 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55538 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55539 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55540 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55541 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55542 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55543 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55544 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55545 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55546 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55547 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55548 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55549 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55550 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55551 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55552 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55553 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55554 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55555 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55556 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55557 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55558 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55559 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55560 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55561 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55562 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55563 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55564 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55565 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55566 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55567 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55568 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55569 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55570 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55571 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55572 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55573 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55574 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55575 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55576 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55577 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55578 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55579 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55580 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55581 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55582 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55583 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55584 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55585 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55586 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55587 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55588 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55589 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55590 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55591 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55592 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55593 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55594 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55595 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55596 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55597 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55598 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55599 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55600 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55601 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55602 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55603 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55604 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55605 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55606 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55607 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55608 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55609 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55610 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55611 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55612 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55613 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55614 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55615 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55616 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55617 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55618 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55619 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55620 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55621 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55622 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55623 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55624 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55625 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55626 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55627 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55628 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55629 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55630 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55631 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55632 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55633 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55634 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55635 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55636 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55637 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55638 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55639 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55640 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55641 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55642 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55643 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55644 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55645 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55646 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55647 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55648 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55649 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55650 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55651 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55652 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55653 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55654 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55655 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55656 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55657 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55658 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55659 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55660 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55661 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55662 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55663 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55664 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55665 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55666 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55667 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55668 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55669 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55670 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55671 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55672 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55673 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55674 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55675 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55676 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55677 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55678 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55679 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55680 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55681 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55682 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55683 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55684 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55685 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55686 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55687 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55688 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55689 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55690 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55691 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55692 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55693 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55694 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55695 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55696 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55697 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55698 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55699 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55700 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55701 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55702 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55703 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55704 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55705 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55706 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55707 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55708 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55709 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55710 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55711 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55712 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55713 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55714 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55715 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55716 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55717 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55718 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55719 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55720 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55721 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55722 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55723 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55724 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55725 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55726 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55727 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55728 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55729 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55730 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55731 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55732 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55733 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55734 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55735 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55736 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55737 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55738 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55739 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55740 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55741 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55742 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55743 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55744 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55745 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55746 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55747 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55748 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55749 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55750 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55751 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55752 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55753 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55754 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55755 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55756 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55757 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55758 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55759 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55760 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55761 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55762 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55763 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55764 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55765 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55766 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55767 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55768 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55769 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55770 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55771 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55772 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55773 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55774 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55775 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55776 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55777 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55778 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55779 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55780 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55781 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55782 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55783 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55784 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55785 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55786 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55787 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55788 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55789 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55790 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55791 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55792 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55793 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55794 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55795 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55796 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55797 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55798 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55799 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55800 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55801 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55802 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55803 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55804 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55805 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55806 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55807 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55808 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55809 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55810 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55811 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55812 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55813 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55814 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55815 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55816 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55817 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55818 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55819 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55820 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55821 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55822 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55823 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55824 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55825 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55826 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55827 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55828 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55829 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55830 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55831 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55832 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55833 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55834 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55835 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55836 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55837 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55838 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55839 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55840 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55841 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55842 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55843 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55844 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55845 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55846 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55847 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55848 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55849 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55850 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55851 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55852 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55853 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55854 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55855 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55856 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55857 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55858 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55859 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55860 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55861 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55862 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55863 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55864 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55865 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55866 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55867 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55868 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55869 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55870 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55871 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55872 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55873 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55874 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55875 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55876 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55877 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55878 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55879 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55880 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55881 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55882 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55883 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55884 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55885 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55886 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55887 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55888 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55889 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55890 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55891 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55892 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55893 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55894 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55895 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55896 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55897 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55898 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55899 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55900 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55901 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55902 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55903 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55904 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55905 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55906 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55907 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55908 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55909 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55910 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55911 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55912 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55913 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55914 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55915 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55916 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55917 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55918 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55919 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55920 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55921 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55922 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55923 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55924 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55925 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55926 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55927 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55928 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55929 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55930 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55931 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55932 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55933 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55934 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55935 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55936 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55937 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55938 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55939 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55940 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55941 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55942 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55943 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55944 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55945 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55946 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55947 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55948 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55949 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55950 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55951 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55952 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55953 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55954 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55955 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55956 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55957 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55958 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55959 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55960 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55961 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55962 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55963 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55964 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55965 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55966 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55967 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55968 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55969 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55970 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55971 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55972 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55973 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55974 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55975 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55976 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55977 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55978 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55979 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55980 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55981 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55982 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55983 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55984 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55985 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55986 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55987 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55988 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55989 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55990 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55991 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55992 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55993 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55994 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55995 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55996 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55997 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55998 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55999 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56000 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56001 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56002 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56003 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56004 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56005 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56006 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56007 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56008 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56009 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56010 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56011 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56012 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56013 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56014 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56015 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56016 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56017 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56018 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56019 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56020 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56021 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56022 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56023 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56024 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56025 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56026 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56027 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56028 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56029 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56030 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56031 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56032 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56033 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56034 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56035 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56036 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56037 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56038 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56039 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56040 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56041 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56042 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56043 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56044 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56045 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56046 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56047 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56048 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56049 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56050 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56051 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56052 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56053 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56054 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56055 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56056 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56057 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56058 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56059 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56060 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56061 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56062 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56063 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56064 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56065 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56066 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56067 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56068 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56069 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56070 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56071 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56072 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56073 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56074 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56075 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56076 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56077 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56078 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56079 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56080 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56081 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56082 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56083 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56084 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56085 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56086 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56087 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56088 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56089
56090 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56091
56092
56093 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56094
56095 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56096 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56097 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56098 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56099 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56100 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56101 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56102 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56103 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56104 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56105 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56106 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56107 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56108 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56109 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56110 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56111 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56112 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56113 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56114 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56115 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56116 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56117 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56118 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56119 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56120 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56121 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56122 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56123 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56124 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56125 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56126 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56127 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56128 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56129 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56130 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56131 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56132 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56133 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56134 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56135 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56136 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56137 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56138 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56139 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56140 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56141 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56142 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56143 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56144 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56145 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56146 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56147 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56148 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56149 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56150 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56151 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56152 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56153 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56154 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56155 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56156 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56157 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56158 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56159 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56160 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56161 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56162 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56163 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56164 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56165 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56166 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56167 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56168 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56169 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56170 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56171 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56172 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56173 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56174 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56175 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56176 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56177 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56178 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56179 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56180 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56181 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56182 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56183 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56184 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56185 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56186 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56187 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56188 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56189 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56190 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56191 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56192 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56193 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56194 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56195 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56196 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56197 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56198 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56199 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56200 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56201 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56202 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56203 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56204 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56205 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56206 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56207 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56208 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56209 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56210 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56211 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56212 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56213 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56214 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56215 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56216 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56217 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56218 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56219 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56220 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56221 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56222 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56223 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56224 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56225 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56226 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56227 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56228 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56229 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56230 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56231 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56232 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56233 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56234 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56235 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56236 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56237 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56238 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56239 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56240 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56241 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56242 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56243 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56244 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56245 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56246 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56247 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56248 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56249 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56250 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56251 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56252 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56253 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56254 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56255 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56256 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56257 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56258 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56259 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56260 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56261 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56262 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56263 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56264 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56265 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56266 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56267 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56268 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56269 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56270 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56271 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56272 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56273 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56274 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56275 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56276 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56277 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56278 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56279 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56280 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56281 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56282 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56283 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56284 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56285 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56286 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56287 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56288 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56289 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56290 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56291 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56292 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56293 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56294 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56295 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56296 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56297 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56298 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56299
56300 // Initialize threading, some globals and such
56301 __wxPyPreStart(d);
56302
56303
56304 // Although these are defined in __version__ they need to be here too so
56305 // that an assert can be done to ensure that the wxPython and the wxWindows
56306 // versions match.
56307 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56308 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56309 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56310
56311 }
56312
wxWidgets (Impactor)