]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Change the wxCharBuffer typemap to make sure there is data before
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTIFFHandler swig_types[124]
2591 #define SWIGTYPE_p_wxToolTip swig_types[125]
2592 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[126]
2593 #define SWIGTYPE_p_wxValidator swig_types[127]
2594 #define SWIGTYPE_p_wxVisualAttributes swig_types[128]
2595 #define SWIGTYPE_p_wxWindow swig_types[129]
2596 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[130]
2597 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[131]
2598 #define SWIGTYPE_p_wxXPMHandler swig_types[132]
2599 #define SWIGTYPE_p_wxZipFSHandler swig_types[133]
2600 static swig_type_info *swig_types[135];
2601 static swig_module_info swig_module = {swig_types, 134, 0, 0, 0, 0};
2602 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2603 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2604
2605 /* -------- TYPES TABLE (END) -------- */
2606
2607 #if (PY_VERSION_HEX <= 0x02000000)
2608 # if !defined(SWIG_PYTHON_CLASSIC)
2609 # error "This python version requires to use swig with the '-classic' option"
2610 # endif
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodern' option"
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodernargs' option"
2617 #endif
2618 #ifndef METH_O
2619 # error "This python version requires to use swig with the '-nofastunpack' option"
2620 #endif
2621
2622 /*-----------------------------------------------
2623 @(target):= _core_.so
2624 ------------------------------------------------*/
2625 #define SWIG_init init_core_
2626
2627 #define SWIG_name "_core_"
2628
2629 #define SWIGVERSION 0x010329
2630
2631
2632 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2633 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2634
2635
2636 #include <stdexcept>
2637
2638
2639 namespace swig {
2640 class PyObject_ptr {
2641 protected:
2642 PyObject *_obj;
2643
2644 public:
2645 PyObject_ptr() :_obj(0)
2646 {
2647 }
2648
2649 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2650 {
2651 Py_XINCREF(_obj);
2652 }
2653
2654 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2655 {
2656 if (initial_ref) Py_XINCREF(_obj);
2657 }
2658
2659 PyObject_ptr & operator=(const PyObject_ptr& item)
2660 {
2661 Py_XINCREF(item._obj);
2662 Py_XDECREF(_obj);
2663 _obj = item._obj;
2664 return *this;
2665 }
2666
2667 ~PyObject_ptr()
2668 {
2669 Py_XDECREF(_obj);
2670 }
2671
2672 operator PyObject *() const
2673 {
2674 return _obj;
2675 }
2676
2677 PyObject *operator->() const
2678 {
2679 return _obj;
2680 }
2681 };
2682 }
2683
2684
2685 namespace swig {
2686 struct PyObject_var : PyObject_ptr {
2687 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2688
2689 PyObject_var & operator = (PyObject* obj)
2690 {
2691 Py_XDECREF(_obj);
2692 _obj = obj;
2693 return *this;
2694 }
2695 };
2696 }
2697
2698
2699 #include "wx/wxPython/wxPython_int.h"
2700 #include "wx/wxPython/pyclasses.h"
2701 #include "wx/wxPython/twoitem.h"
2702
2703
2704 #ifndef wxPyUSE_EXPORT
2705 // Helper functions for dealing with SWIG objects and such. These are
2706 // located here so they know about the SWIG types and functions declared
2707 // in the wrapper code.
2708
2709 #include <wx/hashmap.h>
2710 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2711
2712
2713 // Maintains a hashmap of className to swig_type_info pointers. Given the
2714 // name of a class either looks up the type info in the cache, or scans the
2715 // SWIG tables for it.
2716 extern PyObject* wxPyPtrTypeMap;
2717 static
2718 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2719
2720 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2721
2722 if (typeInfoCache == NULL)
2723 typeInfoCache = new wxPyTypeInfoHashMap;
2724
2725 wxString name(className);
2726 swig_type_info* swigType = (*typeInfoCache)[name];
2727
2728 if (! swigType) {
2729 // it wasn't in the cache, so look it up from SWIG
2730 name.Append(wxT(" *"));
2731 swigType = SWIG_TypeQuery(name.mb_str());
2732
2733 // if it still wasn't found, try looking for a mapped name
2734 if (!swigType) {
2735 PyObject* item;
2736 name = className;
2737
2738 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2739 (char*)(const char*)name.mbc_str())) != NULL) {
2740 name = wxString(PyString_AsString(item), *wxConvCurrent);
2741 name.Append(wxT(" *"));
2742 swigType = SWIG_TypeQuery(name.mb_str());
2743 }
2744 }
2745 if (swigType) {
2746 // and add it to the map if found
2747 (*typeInfoCache)[className] = swigType;
2748 }
2749 }
2750 return swigType;
2751 }
2752
2753
2754 // Check if a class name is a type known to SWIG
2755 bool wxPyCheckSwigType(const wxChar* className) {
2756
2757 swig_type_info* swigType = wxPyFindSwigType(className);
2758 return swigType != NULL;
2759 }
2760
2761
2762 // Given a pointer to a C++ object and a class name, construct a Python proxy
2763 // object for it.
2764 PyObject* wxPyConstructObject(void* ptr,
2765 const wxChar* className,
2766 int setThisOwn) {
2767
2768 swig_type_info* swigType = wxPyFindSwigType(className);
2769 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2770
2771 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2772 }
2773
2774
2775 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2776 // Ensures that the proxy object is of the specified (or derived) type. If
2777 // not able to perform the conversion then a Python exception is set and the
2778 // error should be handled properly in the caller. Returns True on success.
2779 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2780 const wxChar* className) {
2781
2782 swig_type_info* swigType = wxPyFindSwigType(className);
2783 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2784
2785 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2786 }
2787
2788
2789
2790 // Make a SWIGified pointer object suitable for a .this attribute
2791 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2792
2793 PyObject* robj = NULL;
2794
2795 swig_type_info* swigType = wxPyFindSwigType(className);
2796 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2797
2798 robj = PySwigObject_New(ptr, swigType, 0);
2799 return robj;
2800 }
2801
2802
2803 // Python's PyInstance_Check does not return True for instances of new-style
2804 // classes. This should get close enough for both new and old classes but I
2805 // should re-evaluate the need for doing instance checks...
2806 bool wxPyInstance_Check(PyObject* obj) {
2807 return PyObject_HasAttrString(obj, "__class__") != 0;
2808 }
2809
2810
2811 // This one checks if the object is an instance of a SWIG proxy class (it has
2812 // a .this attribute, and the .this attribute is a PySwigObject.)
2813 bool wxPySwigInstance_Check(PyObject* obj) {
2814 static PyObject* this_str = NULL;
2815 if (this_str == NULL)
2816 this_str = PyString_FromString("this");
2817
2818 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2819 if (this_attr) {
2820 bool retval = (PySwigObject_Check(this_attr) != 0);
2821 Py_DECREF(this_attr);
2822 return retval;
2823 }
2824
2825 PyErr_Clear();
2826 return false;
2827 }
2828
2829
2830 // Export a C API in a struct. Other modules will be able to load this from
2831 // the wx._core_ module and will then have safe access to these functions,
2832 // even if they are located in another shared library.
2833 static wxPyCoreAPI API = {
2834
2835 wxPyCheckSwigType,
2836 wxPyConstructObject,
2837 wxPyConvertSwigPtr,
2838 wxPyMakeSwigPtr,
2839
2840 wxPyBeginAllowThreads,
2841 wxPyEndAllowThreads,
2842 wxPyBeginBlockThreads,
2843 wxPyEndBlockThreads,
2844
2845 wxPy_ConvertList,
2846
2847 wxString_in_helper,
2848 Py2wxString,
2849 wx2PyString,
2850
2851 byte_LIST_helper,
2852 int_LIST_helper,
2853 long_LIST_helper,
2854 string_LIST_helper,
2855 wxPoint_LIST_helper,
2856 wxBitmap_LIST_helper,
2857 wxString_LIST_helper,
2858 wxAcceleratorEntry_LIST_helper,
2859
2860 wxSize_helper,
2861 wxPoint_helper,
2862 wxRealPoint_helper,
2863 wxRect_helper,
2864 wxColour_helper,
2865 wxPoint2D_helper,
2866
2867 wxPySimple_typecheck,
2868 wxColour_typecheck,
2869
2870 wxPyCBH_setCallbackInfo,
2871 wxPyCBH_findCallback,
2872 wxPyCBH_callCallback,
2873 wxPyCBH_callCallbackObj,
2874 wxPyCBH_delete,
2875
2876 wxPyMake_wxObject,
2877 wxPyMake_wxSizer,
2878 wxPyPtrTypeMap_Add,
2879 wxPy2int_seq_helper,
2880 wxPy4int_seq_helper,
2881 wxArrayString2PyList_helper,
2882 wxArrayInt2PyList_helper,
2883
2884 wxPyClientData_dtor,
2885 wxPyUserData_dtor,
2886 wxPyOORClientData_dtor,
2887
2888 wxPyCBInputStream_create,
2889 wxPyCBInputStream_copy,
2890
2891 wxPyInstance_Check,
2892 wxPySwigInstance_Check,
2893
2894 wxPyCheckForApp,
2895
2896 wxArrayDouble2PyList_helper,
2897 wxPoint2D_LIST_helper,
2898 wxRect2D_helper,
2899
2900 };
2901
2902 #endif
2903
2904
2905 #if !WXWIN_COMPATIBILITY_2_4
2906 #define wxHIDE_READONLY 0
2907 #endif
2908
2909
2910 #define SWIG_From_long PyInt_FromLong
2911
2912
2913 SWIGINTERNINLINE PyObject *
2914 SWIG_From_int (int value)
2915 {
2916 return SWIG_From_long (value);
2917 }
2918
2919 static const wxString wxPyEmptyString(wxEmptyString);
2920 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2921 return self->GetClassInfo()->GetClassName();
2922 }
2923 SWIGINTERN void wxObject_Destroy(wxObject *self){
2924 delete self;
2925 }
2926
2927 #ifndef __WXMAC__
2928 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2929 #endif
2930
2931
2932 #include <limits.h>
2933 #ifndef LLONG_MIN
2934 # define LLONG_MIN LONG_LONG_MIN
2935 #endif
2936 #ifndef LLONG_MAX
2937 # define LLONG_MAX LONG_LONG_MAX
2938 #endif
2939 #ifndef ULLONG_MAX
2940 # define ULLONG_MAX ULONG_LONG_MAX
2941 #endif
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_long (PyObject* obj, long* val)
2946 {
2947 if (PyNumber_Check(obj)) {
2948 if (val) *val = PyInt_AsLong(obj);
2949 return SWIG_OK;
2950 }
2951 return SWIG_TypeError;
2952 }
2953
2954
2955 SWIGINTERN int
2956 SWIG_AsVal_int (PyObject * obj, int *val)
2957 {
2958 long v;
2959 int res = SWIG_AsVal_long (obj, &v);
2960 if (SWIG_IsOK(res)) {
2961 if ((v < INT_MIN || v > INT_MAX)) {
2962 return SWIG_OverflowError;
2963 } else {
2964 if (val) *val = static_cast< int >(v);
2965 }
2966 }
2967 return res;
2968 }
2969
2970 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2971 wxSize temp, *obj = &temp;
2972 if ( other == Py_None ) return false;
2973 if ( ! wxSize_helper(other, &obj) ) {
2974 PyErr_Clear();
2975 return false;
2976 }
2977 return self->operator==(*obj);
2978 }
2979 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2980 wxSize temp, *obj = &temp;
2981 if ( other == Py_None ) return true;
2982 if ( ! wxSize_helper(other, &obj)) {
2983 PyErr_Clear();
2984 return true;
2985 }
2986 return self->operator!=(*obj);
2987 }
2988
2989 #include <float.h>
2990
2991
2992 SWIGINTERN int
2993 SWIG_AsVal_double (PyObject *obj, double* val)
2994 {
2995 if (PyNumber_Check(obj)) {
2996 if (val) *val = PyFloat_AsDouble(obj);
2997 return SWIG_OK;
2998 }
2999 return SWIG_TypeError;
3000 }
3001
3002
3003 SWIGINTERN int
3004 SWIG_AsVal_float (PyObject * obj, float *val)
3005 {
3006 double v;
3007 int res = SWIG_AsVal_double (obj, &v);
3008 if (SWIG_IsOK(res)) {
3009 if ((v < -FLT_MAX || v > FLT_MAX)) {
3010 return SWIG_OverflowError;
3011 } else {
3012 if (val) *val = static_cast< float >(v);
3013 }
3014 }
3015 return res;
3016 }
3017
3018 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3019 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3023 //wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026
3027 #define SWIG_From_double PyFloat_FromDouble
3028
3029 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3030 wxRealPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxRealPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3039 wxRealPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxRealPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3052 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3056 //PyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3060 wxPoint temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxPoint_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3069 wxPoint temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxPoint_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3078 self->x = x;
3079 self->y = y;
3080 }
3081 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3082 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(2);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 //wxPyEndBlockThreads(blocked);
3087 return tup;
3088 }
3089 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3090 wxRect temp, *obj = &temp;
3091 if ( other == Py_None ) return false;
3092 if ( ! wxRect_helper(other, &obj) ) {
3093 PyErr_Clear();
3094 return false;
3095 }
3096 return self->operator==(*obj);
3097 }
3098 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3099 wxRect temp, *obj = &temp;
3100 if ( other == Py_None ) return true;
3101 if ( ! wxRect_helper(other, &obj)) {
3102 PyErr_Clear();
3103 return true;
3104 }
3105 return self->operator!=(*obj);
3106 }
3107 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3108 self->x = x;
3109 self->y = y;
3110 self->width = width;
3111 self->height = height;
3112 }
3113 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3114 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3115 PyObject* tup = PyTuple_New(4);
3116 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3117 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3118 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3119 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3120 //wxPyEndBlockThreads(blocked);
3121 return tup;
3122 }
3123
3124 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3125 wxRegion reg1(*r1);
3126 wxRegion reg2(*r2);
3127 wxRect dest(0,0,0,0);
3128 PyObject* obj;
3129
3130 reg1.Intersect(reg2);
3131 dest = reg1.GetBox();
3132
3133 if (dest != wxRect(0,0,0,0)) {
3134 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 wxRect* newRect = new wxRect(dest);
3136 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3137 //wxPyEndBlockThreads(blocked);
3138 return obj;
3139 }
3140 Py_INCREF(Py_None);
3141 return Py_None;
3142 }
3143
3144 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3145 wxPoint2D temp, *obj = &temp;
3146 if ( other == Py_None ) return false;
3147 if ( ! wxPoint2D_helper(other, &obj) ) {
3148 PyErr_Clear();
3149 return false;
3150 }
3151 return self->operator==(*obj);
3152 }
3153 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3154 wxPoint2D temp, *obj = &temp;
3155 if ( other == Py_None ) return true;
3156 if ( ! wxPoint2D_helper(other, &obj)) {
3157 PyErr_Clear();
3158 return true;
3159 }
3160 return self->operator!=(*obj);
3161 }
3162 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3163 self->m_x = x;
3164 self->m_y = y;
3165 }
3166 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3167 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3168 PyObject* tup = PyTuple_New(2);
3169 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3170 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3171 //wxPyEndBlockThreads(blocked);
3172 return tup;
3173 }
3174 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3175 wxRect2D temp, *obj = &temp;
3176 if ( other == Py_None ) return false;
3177 if ( ! wxRect2D_helper(other, &obj) ) {
3178 PyErr_Clear();
3179 return false;
3180 }
3181 return self->operator==(*obj);
3182 }
3183 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3184 wxRect2D temp, *obj = &temp;
3185 if ( other == Py_None ) return true;
3186 if ( ! wxRect2D_helper(other, &obj)) {
3187 PyErr_Clear();
3188 return true;
3189 }
3190 return self->operator!=(*obj);
3191 }
3192 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3193 self->m_x = x;
3194 self->m_y = y;
3195 self->m_width = width;
3196 self->m_height = height;
3197 }
3198 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3199 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 PyObject* tup = PyTuple_New(4);
3201 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3202 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3203 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3204 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3205 //wxPyEndBlockThreads(blocked);
3206 return tup;
3207 }
3208
3209 #include "wx/wxPython/pyistream.h"
3210
3211 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3212 wxInputStream* wxis = wxPyCBInputStream::create(p);
3213 if (wxis)
3214 return new wxPyInputStream(wxis);
3215 else
3216 return NULL;
3217 }
3218
3219 SWIGINTERN swig_type_info*
3220 SWIG_pchar_descriptor()
3221 {
3222 static int init = 0;
3223 static swig_type_info* info = 0;
3224 if (!init) {
3225 info = SWIG_TypeQuery("_p_char");
3226 init = 1;
3227 }
3228 return info;
3229 }
3230
3231
3232 SWIGINTERNINLINE PyObject *
3233 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3234 {
3235 if (carray) {
3236 if (size > INT_MAX) {
3237 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3238 return pchar_descriptor ?
3239 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3240 } else {
3241 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3242 }
3243 } else {
3244 return SWIG_Py_Void();
3245 }
3246 }
3247
3248
3249 SWIGINTERNINLINE PyObject *
3250 SWIG_From_char (char c)
3251 {
3252 return SWIG_FromCharPtrAndSize(&c,1);
3253 }
3254
3255
3256 SWIGINTERNINLINE PyObject*
3257 SWIG_From_unsigned_SS_long (unsigned long value)
3258 {
3259 return (value > LONG_MAX) ?
3260 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3261 }
3262
3263
3264 SWIGINTERNINLINE PyObject *
3265 SWIG_From_size_t (size_t value)
3266 {
3267 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3268 }
3269
3270
3271 SWIGINTERN int
3272 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3273 {
3274 if (PyString_Check(obj)) {
3275 char *cstr; Py_ssize_t len;
3276 PyString_AsStringAndSize(obj, &cstr, &len);
3277 if (cptr) {
3278 if (alloc) {
3279 /*
3280 In python the user should not be able to modify the inner
3281 string representation. To warranty that, if you define
3282 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3283 buffer is always returned.
3284
3285 The default behavior is just to return the pointer value,
3286 so, be careful.
3287 */
3288 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3289 if (*alloc != SWIG_OLDOBJ)
3290 #else
3291 if (*alloc == SWIG_NEWOBJ)
3292 #endif
3293 {
3294 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3295 *alloc = SWIG_NEWOBJ;
3296 }
3297 else {
3298 *cptr = cstr;
3299 *alloc = SWIG_OLDOBJ;
3300 }
3301 } else {
3302 *cptr = PyString_AsString(obj);
3303 }
3304 }
3305 if (psize) *psize = len + 1;
3306 return SWIG_OK;
3307 } else {
3308 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3309 if (pchar_descriptor) {
3310 void* vptr = 0;
3311 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3312 if (cptr) *cptr = (char *) vptr;
3313 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3314 if (alloc) *alloc = SWIG_OLDOBJ;
3315 return SWIG_OK;
3316 }
3317 }
3318 }
3319 return SWIG_TypeError;
3320 }
3321
3322
3323 SWIGINTERN int
3324 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3325 {
3326 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3327 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3328 if (SWIG_IsOK(res)) {
3329 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3330 if (csize <= size) {
3331 if (val) {
3332 if (csize) memcpy(val, cptr, csize*sizeof(char));
3333 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3334 }
3335 if (alloc == SWIG_NEWOBJ) {
3336 delete[] cptr;
3337 res = SWIG_DelNewMask(res);
3338 }
3339 return res;
3340 }
3341 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3342 }
3343 return SWIG_TypeError;
3344 }
3345
3346
3347 SWIGINTERN int
3348 SWIG_AsVal_char (PyObject * obj, char *val)
3349 {
3350 int res = SWIG_AsCharArray(obj, val, 1);
3351 if (!SWIG_IsOK(res)) {
3352 long v;
3353 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3354 if (SWIG_IsOK(res)) {
3355 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3356 if (val) *val = static_cast< char >(v);
3357 } else {
3358 res = SWIG_OverflowError;
3359 }
3360 }
3361 }
3362 return res;
3363 }
3364
3365 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3366 // We use only strings for the streams, not unicode
3367 PyObject* str = PyObject_Str(obj);
3368 if (! str) {
3369 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3370 return;
3371 }
3372 self->Write(PyString_AS_STRING(str),
3373 PyString_GET_SIZE(str));
3374 Py_DECREF(str);
3375 }
3376
3377 #include "wx/wxPython/pyistream.h"
3378
3379
3380 class wxPyFileSystemHandler : public wxFileSystemHandler
3381 {
3382 public:
3383 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3384
3385 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3386 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3387 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3388 DEC_PYCALLBACK_STRING__pure(FindNext);
3389
3390 wxString GetProtocol(const wxString& location) {
3391 return wxFileSystemHandler::GetProtocol(location);
3392 }
3393
3394 wxString GetLeftLocation(const wxString& location) {
3395 return wxFileSystemHandler::GetLeftLocation(location);
3396 }
3397
3398 wxString GetAnchor(const wxString& location) {
3399 return wxFileSystemHandler::GetAnchor(location);
3400 }
3401
3402 wxString GetRightLocation(const wxString& location) {
3403 return wxFileSystemHandler::GetRightLocation(location);
3404 }
3405
3406 wxString GetMimeTypeFromExt(const wxString& location) {
3407 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3408 }
3409
3410 PYPRIVATE;
3411 };
3412
3413
3414 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3415 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3416 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3417 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_bool (PyObject *obj, bool *val)
3422 {
3423 if (obj == Py_True) {
3424 if (val) *val = true;
3425 return SWIG_OK;
3426 } else if (obj == Py_False) {
3427 if (val) *val = false;
3428 return SWIG_OK;
3429 } else {
3430 long v = 0;
3431 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3432 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3433 return res;
3434 }
3435 }
3436
3437 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3438 wxFileName fname = wxFileSystem::URLToFileName(url);
3439 return fname.GetFullPath();
3440 }
3441
3442 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3443 wxImage& image,
3444 long type) {
3445 wxMemoryFSHandler::AddFile(filename, image, type);
3446 }
3447
3448 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3449 const wxBitmap& bitmap,
3450 long type) {
3451 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3452 }
3453
3454 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3455 PyObject* data) {
3456 if (! PyString_Check(data)) {
3457 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3458 "Expected string object"));
3459 return;
3460 }
3461
3462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3463 void* ptr = (void*)PyString_AsString(data);
3464 size_t size = PyString_Size(data);
3465 wxPyEndBlockThreads(blocked);
3466
3467 wxMemoryFSHandler::AddFile(filename, ptr, size);
3468 }
3469
3470
3471 #include "wx/wxPython/pyistream.h"
3472
3473
3474 SWIGINTERN int
3475 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3476 {
3477 long v = 0;
3478 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3479 return SWIG_TypeError;
3480 }
3481 else if (val)
3482 *val = (unsigned long)v;
3483 return SWIG_OK;
3484 }
3485
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3489 {
3490 unsigned long v;
3491 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3492 if (SWIG_IsOK(res)) {
3493 if ((v > UCHAR_MAX)) {
3494 return SWIG_OverflowError;
3495 } else {
3496 if (val) *val = static_cast< unsigned char >(v);
3497 }
3498 }
3499 return res;
3500 }
3501
3502
3503 SWIGINTERNINLINE PyObject *
3504 SWIG_From_unsigned_SS_char (unsigned char value)
3505 {
3506 return SWIG_From_unsigned_SS_long (value);
3507 }
3508
3509 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3510 wxImageHistogramEntry e = (*self)[key];
3511 return e.value;
3512 }
3513 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3514 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3515 wxImageHistogramEntry e = (*self)[key];
3516 return e.value;
3517 }
3518 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3519 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3520 colour.Green(),
3521 colour.Blue());
3522 wxImageHistogramEntry e = (*self)[key];
3523 return e.value;
3524 }
3525
3526 // Pull the nested class out to the top level for SWIG's sake
3527 #define wxImage_RGBValue wxImage::RGBValue
3528 #define wxImage_HSVValue wxImage::HSVValue
3529
3530 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3531 if (width > 0 && height > 0)
3532 return new wxImage(width, height, clear);
3533 else
3534 return new wxImage;
3535 }
3536 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3537 return new wxImage(bitmap.ConvertToImage());
3538 }
3539 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3540 if (DATASIZE != width*height*3) {
3541 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3542 return NULL;
3543 }
3544
3545 // Copy the source data so the wxImage can clean it up later
3546 buffer copy = (buffer)malloc(DATASIZE);
3547 if (copy == NULL) {
3548 wxPyBLOCK_THREADS(PyErr_NoMemory());
3549 return NULL;
3550 }
3551 memcpy(copy, data, DATASIZE);
3552 return new wxImage(width, height, copy, false);
3553 }
3554 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3555 if (DATASIZE != width*height*3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return NULL;
3558 }
3559 if (ALPHASIZE != width*height) {
3560 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3561 return NULL;
3562 }
3563
3564 // Copy the source data so the wxImage can clean it up later
3565 buffer dcopy = (buffer)malloc(DATASIZE);
3566 if (dcopy == NULL) {
3567 wxPyBLOCK_THREADS(PyErr_NoMemory());
3568 return NULL;
3569 }
3570 memcpy(dcopy, data, DATASIZE);
3571
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return NULL;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578
3579 return new wxImage(width, height, dcopy, acopy, false);
3580 }
3581 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3582 wxSize size(self->GetWidth(), self->GetHeight());
3583 return size;
3584 }
3585 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3586 buffer data = self->GetData();
3587 int len = self->GetWidth() * self->GetHeight() * 3;
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3590 return rv;
3591 }
3592 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3593 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3595 return;
3596 }
3597 buffer copy = (buffer)malloc(DATASIZE);
3598 if (copy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(copy, data, DATASIZE);
3603 self->SetData(copy, false);
3604 // wxImage takes ownership of copy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3607 buffer data = self->GetData();
3608 int len = self->GetWidth() * self->GetHeight() * 3;
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3614 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3616 return;
3617 }
3618 self->SetData(data, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3621 buffer data = self->GetAlpha();
3622 if (! data) {
3623 RETURN_NONE();
3624 } else {
3625 int len = self->GetWidth() * self->GetHeight();
3626 PyObject* rv;
3627 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3628 return rv;
3629 }
3630 }
3631 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3632 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3633 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3634 return;
3635 }
3636 buffer acopy = (buffer)malloc(ALPHASIZE);
3637 if (acopy == NULL) {
3638 wxPyBLOCK_THREADS(PyErr_NoMemory());
3639 return;
3640 }
3641 memcpy(acopy, alpha, ALPHASIZE);
3642 self->SetAlpha(acopy, false);
3643 // wxImage takes ownership of acopy...
3644 }
3645 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3646 buffer data = self->GetAlpha();
3647 int len = self->GetWidth() * self->GetHeight();
3648 PyObject* rv;
3649 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3650 return rv;
3651 }
3652 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3653 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3654 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3655 return;
3656 }
3657 self->SetAlpha(alpha, true);
3658 }
3659 SWIGINTERN PyObject *wxImage_GetHandlers(){
3660 wxList& list = wxImage::GetHandlers();
3661 return wxPy_ConvertList(&list);
3662 }
3663 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3664 wxBitmap bitmap(*self, depth);
3665 return bitmap;
3666 }
3667 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3668 wxImage mono = self->ConvertToMono( red, green, blue );
3669 wxBitmap bitmap( mono, 1 );
3670 return bitmap;
3671 }
3672
3673 wxImage* _ImageFromBuffer(int width, int height,
3674 buffer data, int DATASIZE,
3675 buffer alpha=NULL, int ALPHASIZE=0)
3676 {
3677 if (DATASIZE != width*height*3) {
3678 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3679 return NULL;
3680 }
3681 if (alpha != NULL) {
3682 if (ALPHASIZE != width*height) {
3683 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3684 return NULL;
3685 }
3686 return new wxImage(width, height, data, alpha, true);
3687 }
3688 return new wxImage(width, height, data, true);
3689 }
3690
3691 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3692 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3693 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3695 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3699 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3700 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3701 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3702 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3703 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3704 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3705 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3706
3707 #include <wx/quantize.h>
3708
3709 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3710 return wxQuantize::Quantize(src, dest,
3711 //NULL, // palette
3712 desiredNoColours,
3713 NULL, // eightBitData
3714 flags);
3715 }
3716 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3717 if (PyCallable_Check(func)) {
3718 self->Connect(id, lastId, eventType,
3719 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3720 new wxPyCallback(func));
3721 }
3722 else if (func == Py_None) {
3723 self->Disconnect(id, lastId, eventType,
3724 (wxObjectEventFunction)
3725 &wxPyCallback::EventThunker);
3726 }
3727 else {
3728 wxPyBLOCK_THREADS(
3729 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3730 }
3731 }
3732 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3733 return self->Disconnect(id, lastId, eventType,
3734 (wxObjectEventFunction)
3735 &wxPyCallback::EventThunker);
3736 }
3737 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3738 if (_self && _self != Py_None) {
3739 self->SetClientObject(new wxPyOORClientData(_self, incref));
3740 }
3741 else {
3742 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3743 if (data) {
3744 self->SetClientObject(NULL); // This will delete it too
3745 }
3746 }
3747 }
3748
3749 #if ! wxUSE_HOTKEY
3750 #define wxEVT_HOTKEY -9999
3751 #endif
3752
3753 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3754 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3755 if (data) {
3756 Py_INCREF(data->m_obj);
3757 return data->m_obj;
3758 } else {
3759 Py_INCREF(Py_None);
3760 return Py_None;
3761 }
3762 }
3763 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3764 wxPyClientData* data = new wxPyClientData(clientData);
3765 self->SetClientObject(data);
3766 }
3767 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3768 #if wxUSE_UNICODE
3769 return self->GetUnicodeKey();
3770 #else
3771 return 0;
3772 #endif
3773 }
3774 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3775 #if wxUSE_UNICODE
3776 self->m_uniChar = uniChar;
3777 #endif
3778 }
3779
3780 SWIGINTERNINLINE PyObject *
3781 SWIG_From_unsigned_SS_int (unsigned int value)
3782 {
3783 return SWIG_From_unsigned_SS_long (value);
3784 }
3785
3786
3787 SWIGINTERN int
3788 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3789 {
3790 unsigned long v;
3791 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3792 if (SWIG_IsOK(res)) {
3793 if ((v > UINT_MAX)) {
3794 return SWIG_OverflowError;
3795 } else {
3796 if (val) *val = static_cast< unsigned int >(v);
3797 }
3798 }
3799 return res;
3800 }
3801
3802 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3803 self->m_size = size;
3804 }
3805 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3806 int count = self->GetNumberOfFiles();
3807 wxString* files = self->GetFiles();
3808 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3809 PyObject* list = PyList_New(count);
3810
3811 if (!list) {
3812 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3813 wxPyEndBlockThreads(blocked);
3814 return NULL;
3815 }
3816
3817 for (int i=0; i<count; i++) {
3818 PyList_SetItem(list, i, wx2PyString(files[i]));
3819 }
3820 wxPyEndBlockThreads(blocked);
3821 return list;
3822 }
3823
3824
3825 SWIGINTERN wxPyApp *new_wxPyApp(){
3826 wxPythonApp = new wxPyApp();
3827 return wxPythonApp;
3828 }
3829 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3830 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3831 return wxPyTestDisplayAvailable();
3832 }
3833
3834 void wxApp_CleanUp() {
3835 __wxPyCleanup();
3836 }
3837
3838
3839 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3840
3841
3842
3843
3844
3845 SWIGINTERNINLINE PyObject *
3846 SWIG_FromCharPtr(const char *cptr)
3847 {
3848 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3849 }
3850
3851
3852 #if 0 // #ifdef __WXMAC__
3853
3854 // A dummy class that raises an exception if used...
3855 class wxEventLoop
3856 {
3857 public:
3858 wxEventLoop() { wxPyRaiseNotImplemented(); }
3859 int Run() { return 0; }
3860 void Exit(int rc = 0) {}
3861 bool Pending() const { return false; }
3862 bool Dispatch() { return false; }
3863 bool IsRunning() const { return false; }
3864 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3865 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3866 };
3867
3868 #else
3869
3870 #include <wx/evtloop.h>
3871
3872 #endif
3873
3874
3875
3876 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3877 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3878 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3879 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3880 wxWindowList& list = self->GetChildren();
3881 return wxPy_ConvertList(&list);
3882 }
3883 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3884 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3885 #if wxUSE_HOTKEY
3886 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3887 #else
3888 return false;
3889 #endif
3890 }
3891 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3892
3893
3894
3895 return false;
3896
3897 }
3898 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3899 return wxPyGetWinHandle(self);
3900 }
3901 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3902 self->AssociateHandle((WXWidget)handle);
3903 }
3904 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3905
3906 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3907 return wxWindow::FindWindowById(id, parent);
3908 }
3909
3910 wxWindow* wxFindWindowByName( const wxString& name,
3911 const wxWindow *parent = NULL ) {
3912 return wxWindow::FindWindowByName(name, parent);
3913 }
3914
3915 wxWindow* wxFindWindowByLabel( const wxString& label,
3916 const wxWindow *parent = NULL ) {
3917 return wxWindow::FindWindowByLabel(label, parent);
3918 }
3919
3920
3921 #ifdef __WXMSW__
3922 #include <wx/msw/private.h> // to get wxGetWindowId
3923 #endif
3924
3925
3926 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3927 #ifdef __WXMSW__
3928 WXHWND hWnd = (WXHWND)_hWnd;
3929 long id = wxGetWindowId(hWnd);
3930 wxWindow* win = new wxWindow;
3931 if (parent)
3932 parent->AddChild(win);
3933 win->SetEventHandler(win);
3934 win->SetHWND(hWnd);
3935 win->SetId(id);
3936 win->SubclassWin(hWnd);
3937 win->AdoptAttributesFromHWND();
3938 win->SetupColours();
3939 return win;
3940 #else
3941 wxPyRaiseNotImplemented();
3942 return NULL;
3943 #endif
3944 }
3945
3946
3947 PyObject* GetTopLevelWindows() {
3948 return wxPy_ConvertList(&wxTopLevelWindows);
3949 }
3950
3951
3952 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3953 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3954 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3955
3956 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3957
3958
3959 SWIGINTERNINLINE int
3960 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3961 {
3962 unsigned long v;
3963 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3964 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3965 return res;
3966 }
3967
3968 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3969 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3970 wxMenuItemList& list = self->GetMenuItems();
3971 return wxPy_ConvertList(&list);
3972 }
3973 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3974 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3975 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3976 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3977 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3978 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3979 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3980 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3981 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3982 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3983 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3984 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3985 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3986 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3987 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3988 static const wxString wxPyControlNameStr(wxControlNameStr);
3989 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3990 if (clientData) {
3991 wxPyClientData* data = new wxPyClientData(clientData);
3992 return self->Append(item, data);
3993 } else
3994 return self->Append(item);
3995 }
3996 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3997 if (clientData) {
3998 wxPyClientData* data = new wxPyClientData(clientData);
3999 return self->Insert(item, pos, data);
4000 } else
4001 return self->Insert(item, pos);
4002 }
4003 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4004 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4005 if (data) {
4006 Py_INCREF(data->m_obj);
4007 return data->m_obj;
4008 } else {
4009 Py_INCREF(Py_None);
4010 return Py_None;
4011 }
4012 }
4013 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4014 wxPyClientData* data = new wxPyClientData(clientData);
4015 self->SetClientObject(n, data);
4016 }
4017
4018
4019 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4020 wxPyUserData* data = NULL;
4021 if ( userData ) {
4022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4023 data = new wxPyUserData(userData);
4024 wxPyEndBlockThreads(blocked);
4025 }
4026 return new wxSizerItem(window, proportion, flag, border, data);
4027 }
4028 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4029 wxPyUserData* data = NULL;
4030 if ( userData ) {
4031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4032 data = new wxPyUserData(userData);
4033 wxPyEndBlockThreads(blocked);
4034 }
4035 return new wxSizerItem(width, height, proportion, flag, border, data);
4036 }
4037 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4038 wxPyUserData* data = NULL;
4039 if ( userData ) {
4040 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4041 data = new wxPyUserData(userData);
4042 wxPyEndBlockThreads(blocked);
4043 }
4044 return new wxSizerItem(sizer, proportion, flag, border, data);
4045 }
4046
4047 SWIGINTERNINLINE PyObject *
4048 SWIG_From_float (float value)
4049 {
4050 return SWIG_From_double (value);
4051 }
4052
4053 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4054 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4055 if (data) {
4056 Py_INCREF(data->m_obj);
4057 return data->m_obj;
4058 } else {
4059 Py_INCREF(Py_None);
4060 return Py_None;
4061 }
4062 }
4063 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4064 wxPyUserData* data = NULL;
4065 if ( userData ) {
4066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4067 data = new wxPyUserData(userData);
4068 wxPyEndBlockThreads(blocked);
4069 }
4070 self->SetUserData(data);
4071 }
4072
4073 // Figure out the type of the sizer item
4074
4075 struct wxPySizerItemInfo {
4076 wxPySizerItemInfo()
4077 : window(NULL), sizer(NULL), gotSize(false),
4078 size(wxDefaultSize), gotPos(false), pos(-1)
4079 {}
4080
4081 wxWindow* window;
4082 wxSizer* sizer;
4083 bool gotSize;
4084 wxSize size;
4085 bool gotPos;
4086 int pos;
4087 };
4088
4089 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4090
4091 wxPySizerItemInfo info;
4092 wxSize size;
4093 wxSize* sizePtr = &size;
4094
4095 // Find out what the type of the item is
4096 // try wxWindow
4097 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4098 PyErr_Clear();
4099 info.window = NULL;
4100
4101 // try wxSizer
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4103 PyErr_Clear();
4104 info.sizer = NULL;
4105
4106 // try wxSize or (w,h)
4107 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4108 info.size = *sizePtr;
4109 info.gotSize = true;
4110 }
4111
4112 // or a single int
4113 if (checkIdx && PyInt_Check(item)) {
4114 info.pos = PyInt_AsLong(item);
4115 info.gotPos = true;
4116 }
4117 }
4118 }
4119
4120 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4121 // no expected type, figure out what kind of error message to generate
4122 if ( !checkSize && !checkIdx )
4123 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4124 else if ( checkSize && !checkIdx )
4125 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4126 else if ( !checkSize && checkIdx)
4127 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4128 else
4129 // can this one happen?
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4131 }
4132
4133 return info;
4134 }
4135
4136 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4137 if (!self->GetClientObject())
4138 self->SetClientObject(new wxPyOORClientData(_self));
4139 }
4140 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4141
4142 wxPyUserData* data = NULL;
4143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4145 if ( userData && (info.window || info.sizer || info.gotSize) )
4146 data = new wxPyUserData(userData);
4147 if ( info.sizer )
4148 PyObject_SetAttrString(item,"thisown",Py_False);
4149 wxPyEndBlockThreads(blocked);
4150
4151 // Now call the real Add method if a valid item type was found
4152 if ( info.window )
4153 return self->Add(info.window, proportion, flag, border, data);
4154 else if ( info.sizer )
4155 return self->Add(info.sizer, proportion, flag, border, data);
4156 else if (info.gotSize)
4157 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4158 proportion, flag, border, data);
4159 else
4160 return NULL;
4161 }
4162 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4163
4164 wxPyUserData* data = NULL;
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4167 if ( userData && (info.window || info.sizer || info.gotSize) )
4168 data = new wxPyUserData(userData);
4169 if ( info.sizer )
4170 PyObject_SetAttrString(item,"thisown",Py_False);
4171 wxPyEndBlockThreads(blocked);
4172
4173 // Now call the real Insert method if a valid item type was found
4174 if ( info.window )
4175 return self->Insert(before, info.window, proportion, flag, border, data);
4176 else if ( info.sizer )
4177 return self->Insert(before, info.sizer, proportion, flag, border, data);
4178 else if (info.gotSize)
4179 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4180 proportion, flag, border, data);
4181 else
4182 return NULL;
4183 }
4184 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4185
4186 wxPyUserData* data = NULL;
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4189 if ( userData && (info.window || info.sizer || info.gotSize) )
4190 data = new wxPyUserData(userData);
4191 if ( info.sizer )
4192 PyObject_SetAttrString(item,"thisown",Py_False);
4193 wxPyEndBlockThreads(blocked);
4194
4195 // Now call the real Prepend method if a valid item type was found
4196 if ( info.window )
4197 return self->Prepend(info.window, proportion, flag, border, data);
4198 else if ( info.sizer )
4199 return self->Prepend(info.sizer, proportion, flag, border, data);
4200 else if (info.gotSize)
4201 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4202 proportion, flag, border, data);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 return self->Remove(info.window);
4212 else if ( info.sizer )
4213 return self->Remove(info.sizer);
4214 else if ( info.gotPos )
4215 return self->Remove(info.pos);
4216 else
4217 return false;
4218 }
4219 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4221 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4222 wxPyEndBlockThreads(blocked);
4223 if ( info.window )
4224 return self->Detach(info.window);
4225 else if ( info.sizer )
4226 return self->Detach(info.sizer);
4227 else if ( info.gotPos )
4228 return self->Detach(info.pos);
4229 else
4230 return false;
4231 }
4232 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4234 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4235 wxPyEndBlockThreads(blocked);
4236 if ( info.window )
4237 return self->GetItem(info.window);
4238 else if ( info.sizer )
4239 return self->GetItem(info.sizer);
4240 else if ( info.gotPos )
4241 return self->GetItem(info.pos);
4242 else
4243 return NULL;
4244 }
4245 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4248 wxPyEndBlockThreads(blocked);
4249 if ( info.window )
4250 self->SetItemMinSize(info.window, size);
4251 else if ( info.sizer )
4252 self->SetItemMinSize(info.sizer, size);
4253 else if ( info.gotPos )
4254 self->SetItemMinSize(info.pos, size);
4255 }
4256 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4257 wxSizerItemList& list = self->GetChildren();
4258 return wxPy_ConvertList(&list);
4259 }
4260 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4261 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4262 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4263 wxPyEndBlockThreads(blocked);
4264 if ( info.window )
4265 return self->Show(info.window, show, recursive);
4266 else if ( info.sizer )
4267 return self->Show(info.sizer, show, recursive);
4268 else if ( info.gotPos )
4269 return self->Show(info.pos, show);
4270 else
4271 return false;
4272 }
4273 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4274 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4275 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4276 wxPyEndBlockThreads(blocked);
4277 if ( info.window )
4278 return self->IsShown(info.window);
4279 else if ( info.sizer )
4280 return self->IsShown(info.sizer);
4281 else if ( info.gotPos )
4282 return self->IsShown(info.pos);
4283 else
4284 return false;
4285 }
4286
4287 // See pyclasses.h
4288 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4289 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4290 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4291
4292
4293
4294
4295 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4296 {
4297 if (source == Py_None) {
4298 **obj = wxGBPosition(-1,-1);
4299 return true;
4300 }
4301 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4302 }
4303
4304 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4305 {
4306 if (source == Py_None) {
4307 **obj = wxGBSpan(-1,-1);
4308 return true;
4309 }
4310 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4311 }
4312
4313
4314 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4315 wxGBPosition temp, *obj = &temp;
4316 if ( other == Py_None ) return false;
4317 if ( ! wxGBPosition_helper(other, &obj) ) {
4318 PyErr_Clear();
4319 return false;
4320 }
4321 return self->operator==(*obj);
4322 }
4323 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4324 wxGBPosition temp, *obj = &temp;
4325 if ( other == Py_None ) return true;
4326 if ( ! wxGBPosition_helper(other, &obj)) {
4327 PyErr_Clear();
4328 return true;
4329 }
4330 return self->operator!=(*obj);
4331 }
4332 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4333 self->SetRow(row);
4334 self->SetCol(col);
4335 }
4336 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 PyObject* tup = PyTuple_New(2);
4339 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4340 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4341 wxPyEndBlockThreads(blocked);
4342 return tup;
4343 }
4344 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4345 wxGBSpan temp, *obj = &temp;
4346 if ( other == Py_None ) return false;
4347 if ( ! wxGBSpan_helper(other, &obj) ) {
4348 PyErr_Clear();
4349 return false;
4350 }
4351 return self->operator==(*obj);
4352 }
4353 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4354 wxGBSpan temp, *obj = &temp;
4355 if ( other == Py_None ) return true;
4356 if ( ! wxGBSpan_helper(other, &obj)) {
4357 PyErr_Clear();
4358 return true;
4359 }
4360 return self->operator!=(*obj);
4361 }
4362 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4363 self->SetRowspan(rowspan);
4364 self->SetColspan(colspan);
4365 }
4366 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4367 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4368 PyObject* tup = PyTuple_New(2);
4369 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4370 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4371 wxPyEndBlockThreads(blocked);
4372 return tup;
4373 }
4374 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4375 wxPyUserData* data = NULL;
4376 if ( userData ) {
4377 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4378 data = new wxPyUserData(userData);
4379 wxPyEndBlockThreads(blocked);
4380 }
4381 return new wxGBSizerItem(window, pos, span, flag, border, data);
4382 }
4383 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4384 wxPyUserData* data = NULL;
4385 if ( userData ) {
4386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4387 data = new wxPyUserData(userData);
4388 wxPyEndBlockThreads(blocked);
4389 }
4390 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4391 }
4392 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4393 wxPyUserData* data = NULL;
4394 if ( userData ) {
4395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4396 data = new wxPyUserData(userData);
4397 wxPyEndBlockThreads(blocked);
4398 }
4399 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4400 }
4401 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4402 int row, col;
4403 self->GetEndPos(row, col);
4404 return wxGBPosition(row, col);
4405 }
4406 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4407
4408 wxPyUserData* data = NULL;
4409 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4410 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4411 if ( userData && (info.window || info.sizer || info.gotSize) )
4412 data = new wxPyUserData(userData);
4413 if ( info.sizer )
4414 PyObject_SetAttrString(item,"thisown",Py_False);
4415 wxPyEndBlockThreads(blocked);
4416
4417 // Now call the real Add method if a valid item type was found
4418 if ( info.window )
4419 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4420 else if ( info.sizer )
4421 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4422 else if (info.gotSize)
4423 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4424 pos, span, flag, border, data);
4425 return NULL;
4426 }
4427
4428
4429 #ifdef __cplusplus
4430 extern "C" {
4431 #endif
4432 SWIGINTERN int EmptyString_set(PyObject *) {
4433 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4434 return 1;
4435 }
4436
4437
4438 SWIGINTERN PyObject *EmptyString_get(void) {
4439 PyObject *pyobj = 0;
4440
4441 {
4442 #if wxUSE_UNICODE
4443 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4444 #else
4445 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4446 #endif
4447 }
4448 return pyobj;
4449 }
4450
4451
4452 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4453 PyObject *resultobj = 0;
4454 wxObject *arg1 = (wxObject *) 0 ;
4455 wxString result;
4456 void *argp1 = 0 ;
4457 int res1 = 0 ;
4458 PyObject *swig_obj[1] ;
4459
4460 if (!args) SWIG_fail;
4461 swig_obj[0] = args;
4462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4463 if (!SWIG_IsOK(res1)) {
4464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4465 }
4466 arg1 = reinterpret_cast< wxObject * >(argp1);
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 result = wxObject_GetClassName(arg1);
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 {
4474 #if wxUSE_UNICODE
4475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4476 #else
4477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4478 #endif
4479 }
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 PyObject *resultobj = 0;
4488 wxObject *arg1 = (wxObject *) 0 ;
4489 void *argp1 = 0 ;
4490 int res1 = 0 ;
4491 PyObject *swig_obj[1] ;
4492
4493 if (!args) SWIG_fail;
4494 swig_obj[0] = args;
4495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4496 if (!SWIG_IsOK(res1)) {
4497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4498 }
4499 arg1 = reinterpret_cast< wxObject * >(argp1);
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 wxObject_Destroy(arg1);
4503 wxPyEndAllowThreads(__tstate);
4504 if (PyErr_Occurred()) SWIG_fail;
4505 }
4506 resultobj = SWIG_Py_Void();
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj = 0;
4515 wxObject *arg1 = (wxObject *) 0 ;
4516 wxObject *arg2 = 0 ;
4517 bool result;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 void *argp2 = 0 ;
4521 int res2 = 0 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char * kwnames[] = {
4525 (char *) "self",(char *) "p", NULL
4526 };
4527
4528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4532 }
4533 arg1 = reinterpret_cast< wxObject * >(argp1);
4534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4535 if (!SWIG_IsOK(res2)) {
4536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4537 }
4538 if (!argp2) {
4539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4540 }
4541 arg2 = reinterpret_cast< wxObject * >(argp2);
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4550 }
4551 return resultobj;
4552 fail:
4553 return NULL;
4554 }
4555
4556
4557 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4558 PyObject *obj;
4559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4560 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4561 return SWIG_Py_Void();
4562 }
4563
4564 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int arg2 ;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 int val2 ;
4571 int ecode2 = 0 ;
4572 PyObject *swig_obj[2] ;
4573
4574 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4576 if (!SWIG_IsOK(res1)) {
4577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4578 }
4579 arg1 = reinterpret_cast< wxSize * >(argp1);
4580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4581 if (!SWIG_IsOK(ecode2)) {
4582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4583 }
4584 arg2 = static_cast< int >(val2);
4585 if (arg1) (arg1)->x = arg2;
4586
4587 resultobj = SWIG_Py_Void();
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 wxSize *arg1 = (wxSize *) 0 ;
4597 int result;
4598 void *argp1 = 0 ;
4599 int res1 = 0 ;
4600 PyObject *swig_obj[1] ;
4601
4602 if (!args) SWIG_fail;
4603 swig_obj[0] = args;
4604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4605 if (!SWIG_IsOK(res1)) {
4606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4607 }
4608 arg1 = reinterpret_cast< wxSize * >(argp1);
4609 result = (int) ((arg1)->x);
4610 resultobj = SWIG_From_int(static_cast< int >(result));
4611 return resultobj;
4612 fail:
4613 return NULL;
4614 }
4615
4616
4617 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4618 PyObject *resultobj = 0;
4619 wxSize *arg1 = (wxSize *) 0 ;
4620 int arg2 ;
4621 void *argp1 = 0 ;
4622 int res1 = 0 ;
4623 int val2 ;
4624 int ecode2 = 0 ;
4625 PyObject *swig_obj[2] ;
4626
4627 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4629 if (!SWIG_IsOK(res1)) {
4630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4631 }
4632 arg1 = reinterpret_cast< wxSize * >(argp1);
4633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4634 if (!SWIG_IsOK(ecode2)) {
4635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4636 }
4637 arg2 = static_cast< int >(val2);
4638 if (arg1) (arg1)->y = arg2;
4639
4640 resultobj = SWIG_Py_Void();
4641 return resultobj;
4642 fail:
4643 return NULL;
4644 }
4645
4646
4647 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4648 PyObject *resultobj = 0;
4649 wxSize *arg1 = (wxSize *) 0 ;
4650 int result;
4651 void *argp1 = 0 ;
4652 int res1 = 0 ;
4653 PyObject *swig_obj[1] ;
4654
4655 if (!args) SWIG_fail;
4656 swig_obj[0] = args;
4657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4658 if (!SWIG_IsOK(res1)) {
4659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4660 }
4661 arg1 = reinterpret_cast< wxSize * >(argp1);
4662 result = (int) ((arg1)->y);
4663 resultobj = SWIG_From_int(static_cast< int >(result));
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 int arg1 = (int) 0 ;
4673 int arg2 = (int) 0 ;
4674 wxSize *result = 0 ;
4675 int val1 ;
4676 int ecode1 = 0 ;
4677 int val2 ;
4678 int ecode2 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "w",(char *) "h", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4686 if (obj0) {
4687 ecode1 = SWIG_AsVal_int(obj0, &val1);
4688 if (!SWIG_IsOK(ecode1)) {
4689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4690 }
4691 arg1 = static_cast< int >(val1);
4692 }
4693 if (obj1) {
4694 ecode2 = SWIG_AsVal_int(obj1, &val2);
4695 if (!SWIG_IsOK(ecode2)) {
4696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4697 }
4698 arg2 = static_cast< int >(val2);
4699 }
4700 {
4701 result = (wxSize *)new wxSize(arg1,arg2);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712 PyObject *resultobj = 0;
4713 wxSize *arg1 = (wxSize *) 0 ;
4714 void *argp1 = 0 ;
4715 int res1 = 0 ;
4716 PyObject *swig_obj[1] ;
4717
4718 if (!args) SWIG_fail;
4719 swig_obj[0] = args;
4720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4723 }
4724 arg1 = reinterpret_cast< wxSize * >(argp1);
4725 {
4726 delete arg1;
4727
4728 if (PyErr_Occurred()) SWIG_fail;
4729 }
4730 resultobj = SWIG_Py_Void();
4731 return resultobj;
4732 fail:
4733 return NULL;
4734 }
4735
4736
4737 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4738 PyObject *resultobj = 0;
4739 wxSize *arg1 = (wxSize *) 0 ;
4740 PyObject *arg2 = (PyObject *) 0 ;
4741 bool result;
4742 void *argp1 = 0 ;
4743 int res1 = 0 ;
4744 PyObject * obj0 = 0 ;
4745 PyObject * obj1 = 0 ;
4746 char * kwnames[] = {
4747 (char *) "self",(char *) "other", NULL
4748 };
4749
4750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4752 if (!SWIG_IsOK(res1)) {
4753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4754 }
4755 arg1 = reinterpret_cast< wxSize * >(argp1);
4756 arg2 = obj1;
4757 {
4758 result = (bool)wxSize___eq__(arg1,arg2);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 {
4762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4763 }
4764 return resultobj;
4765 fail:
4766 return NULL;
4767 }
4768
4769
4770 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4771 PyObject *resultobj = 0;
4772 wxSize *arg1 = (wxSize *) 0 ;
4773 PyObject *arg2 = (PyObject *) 0 ;
4774 bool result;
4775 void *argp1 = 0 ;
4776 int res1 = 0 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char * kwnames[] = {
4780 (char *) "self",(char *) "other", NULL
4781 };
4782
4783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4785 if (!SWIG_IsOK(res1)) {
4786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4787 }
4788 arg1 = reinterpret_cast< wxSize * >(argp1);
4789 arg2 = obj1;
4790 {
4791 result = (bool)wxSize___ne__(arg1,arg2);
4792 if (PyErr_Occurred()) SWIG_fail;
4793 }
4794 {
4795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4796 }
4797 return resultobj;
4798 fail:
4799 return NULL;
4800 }
4801
4802
4803 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4804 PyObject *resultobj = 0;
4805 wxSize *arg1 = (wxSize *) 0 ;
4806 wxSize *arg2 = 0 ;
4807 wxSize result;
4808 void *argp1 = 0 ;
4809 int res1 = 0 ;
4810 wxSize temp2 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "self",(char *) "sz", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4819 if (!SWIG_IsOK(res1)) {
4820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4821 }
4822 arg1 = reinterpret_cast< wxSize * >(argp1);
4823 {
4824 arg2 = &temp2;
4825 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4826 }
4827 {
4828 result = (arg1)->operator +((wxSize const &)*arg2);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj = 0;
4840 wxSize *arg1 = (wxSize *) 0 ;
4841 wxSize *arg2 = 0 ;
4842 wxSize result;
4843 void *argp1 = 0 ;
4844 int res1 = 0 ;
4845 wxSize temp2 ;
4846 PyObject * obj0 = 0 ;
4847 PyObject * obj1 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "sz", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 {
4859 arg2 = &temp2;
4860 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4861 }
4862 {
4863 result = (arg1)->operator -((wxSize const &)*arg2);
4864 if (PyErr_Occurred()) SWIG_fail;
4865 }
4866 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4867 return resultobj;
4868 fail:
4869 return NULL;
4870 }
4871
4872
4873 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4874 PyObject *resultobj = 0;
4875 wxSize *arg1 = (wxSize *) 0 ;
4876 wxSize *arg2 = 0 ;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 wxSize temp2 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 char * kwnames[] = {
4883 (char *) "self",(char *) "sz", NULL
4884 };
4885
4886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4888 if (!SWIG_IsOK(res1)) {
4889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4890 }
4891 arg1 = reinterpret_cast< wxSize * >(argp1);
4892 {
4893 arg2 = &temp2;
4894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4895 }
4896 {
4897 (arg1)->IncTo((wxSize const &)*arg2);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 resultobj = SWIG_Py_Void();
4901 return resultobj;
4902 fail:
4903 return NULL;
4904 }
4905
4906
4907 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4908 PyObject *resultobj = 0;
4909 wxSize *arg1 = (wxSize *) 0 ;
4910 wxSize *arg2 = 0 ;
4911 void *argp1 = 0 ;
4912 int res1 = 0 ;
4913 wxSize temp2 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "sz", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",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_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4924 }
4925 arg1 = reinterpret_cast< wxSize * >(argp1);
4926 {
4927 arg2 = &temp2;
4928 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4929 }
4930 {
4931 (arg1)->DecTo((wxSize const &)*arg2);
4932 if (PyErr_Occurred()) SWIG_fail;
4933 }
4934 resultobj = SWIG_Py_Void();
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj = 0;
4943 wxSize *arg1 = (wxSize *) 0 ;
4944 int arg2 ;
4945 int arg3 ;
4946 void *argp1 = 0 ;
4947 int res1 = 0 ;
4948 int val2 ;
4949 int ecode2 = 0 ;
4950 int val3 ;
4951 int ecode3 = 0 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 PyObject * obj2 = 0 ;
4955 char * kwnames[] = {
4956 (char *) "self",(char *) "dx",(char *) "dy", NULL
4957 };
4958
4959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4961 if (!SWIG_IsOK(res1)) {
4962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4963 }
4964 arg1 = reinterpret_cast< wxSize * >(argp1);
4965 ecode2 = SWIG_AsVal_int(obj1, &val2);
4966 if (!SWIG_IsOK(ecode2)) {
4967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4968 }
4969 arg2 = static_cast< int >(val2);
4970 ecode3 = SWIG_AsVal_int(obj2, &val3);
4971 if (!SWIG_IsOK(ecode3)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4973 }
4974 arg3 = static_cast< int >(val3);
4975 {
4976 (arg1)->IncBy(arg2,arg3);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 int arg2 ;
4990 int arg3 ;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 int val2 ;
4994 int ecode2 = 0 ;
4995 int val3 ;
4996 int ecode3 = 0 ;
4997 PyObject * obj0 = 0 ;
4998 PyObject * obj1 = 0 ;
4999 PyObject * obj2 = 0 ;
5000 char * kwnames[] = {
5001 (char *) "self",(char *) "dx",(char *) "dy", NULL
5002 };
5003
5004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5006 if (!SWIG_IsOK(res1)) {
5007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5008 }
5009 arg1 = reinterpret_cast< wxSize * >(argp1);
5010 ecode2 = SWIG_AsVal_int(obj1, &val2);
5011 if (!SWIG_IsOK(ecode2)) {
5012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5013 }
5014 arg2 = static_cast< int >(val2);
5015 ecode3 = SWIG_AsVal_int(obj2, &val3);
5016 if (!SWIG_IsOK(ecode3)) {
5017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5018 }
5019 arg3 = static_cast< int >(val3);
5020 {
5021 (arg1)->DecBy(arg2,arg3);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 resultobj = SWIG_Py_Void();
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5032 PyObject *resultobj = 0;
5033 wxSize *arg1 = (wxSize *) 0 ;
5034 float arg2 ;
5035 float arg3 ;
5036 void *argp1 = 0 ;
5037 int res1 = 0 ;
5038 float val2 ;
5039 int ecode2 = 0 ;
5040 float val3 ;
5041 int ecode3 = 0 ;
5042 PyObject * obj0 = 0 ;
5043 PyObject * obj1 = 0 ;
5044 PyObject * obj2 = 0 ;
5045 char * kwnames[] = {
5046 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5047 };
5048
5049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 ecode2 = SWIG_AsVal_float(obj1, &val2);
5056 if (!SWIG_IsOK(ecode2)) {
5057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5058 }
5059 arg2 = static_cast< float >(val2);
5060 ecode3 = SWIG_AsVal_float(obj2, &val3);
5061 if (!SWIG_IsOK(ecode3)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5063 }
5064 arg3 = static_cast< float >(val3);
5065 {
5066 (arg1)->Scale(arg2,arg3);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_Py_Void();
5070 return resultobj;
5071 fail:
5072 return NULL;
5073 }
5074
5075
5076 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5077 PyObject *resultobj = 0;
5078 wxSize *arg1 = (wxSize *) 0 ;
5079 int arg2 ;
5080 int arg3 ;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 int val2 ;
5084 int ecode2 = 0 ;
5085 int val3 ;
5086 int ecode3 = 0 ;
5087 PyObject * obj0 = 0 ;
5088 PyObject * obj1 = 0 ;
5089 PyObject * obj2 = 0 ;
5090 char * kwnames[] = {
5091 (char *) "self",(char *) "w",(char *) "h", NULL
5092 };
5093
5094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5096 if (!SWIG_IsOK(res1)) {
5097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5098 }
5099 arg1 = reinterpret_cast< wxSize * >(argp1);
5100 ecode2 = SWIG_AsVal_int(obj1, &val2);
5101 if (!SWIG_IsOK(ecode2)) {
5102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5103 }
5104 arg2 = static_cast< int >(val2);
5105 ecode3 = SWIG_AsVal_int(obj2, &val3);
5106 if (!SWIG_IsOK(ecode3)) {
5107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5108 }
5109 arg3 = static_cast< int >(val3);
5110 {
5111 (arg1)->Set(arg2,arg3);
5112 if (PyErr_Occurred()) SWIG_fail;
5113 }
5114 resultobj = SWIG_Py_Void();
5115 return resultobj;
5116 fail:
5117 return NULL;
5118 }
5119
5120
5121 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5122 PyObject *resultobj = 0;
5123 wxSize *arg1 = (wxSize *) 0 ;
5124 int arg2 ;
5125 void *argp1 = 0 ;
5126 int res1 = 0 ;
5127 int val2 ;
5128 int ecode2 = 0 ;
5129 PyObject * obj0 = 0 ;
5130 PyObject * obj1 = 0 ;
5131 char * kwnames[] = {
5132 (char *) "self",(char *) "w", NULL
5133 };
5134
5135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5137 if (!SWIG_IsOK(res1)) {
5138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5139 }
5140 arg1 = reinterpret_cast< wxSize * >(argp1);
5141 ecode2 = SWIG_AsVal_int(obj1, &val2);
5142 if (!SWIG_IsOK(ecode2)) {
5143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5144 }
5145 arg2 = static_cast< int >(val2);
5146 {
5147 (arg1)->SetWidth(arg2);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 resultobj = SWIG_Py_Void();
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5158 PyObject *resultobj = 0;
5159 wxSize *arg1 = (wxSize *) 0 ;
5160 int arg2 ;
5161 void *argp1 = 0 ;
5162 int res1 = 0 ;
5163 int val2 ;
5164 int ecode2 = 0 ;
5165 PyObject * obj0 = 0 ;
5166 PyObject * obj1 = 0 ;
5167 char * kwnames[] = {
5168 (char *) "self",(char *) "h", NULL
5169 };
5170
5171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 ecode2 = SWIG_AsVal_int(obj1, &val2);
5178 if (!SWIG_IsOK(ecode2)) {
5179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5180 }
5181 arg2 = static_cast< int >(val2);
5182 {
5183 (arg1)->SetHeight(arg2);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_Py_Void();
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5194 PyObject *resultobj = 0;
5195 wxSize *arg1 = (wxSize *) 0 ;
5196 int result;
5197 void *argp1 = 0 ;
5198 int res1 = 0 ;
5199 PyObject *swig_obj[1] ;
5200
5201 if (!args) SWIG_fail;
5202 swig_obj[0] = args;
5203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5204 if (!SWIG_IsOK(res1)) {
5205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5206 }
5207 arg1 = reinterpret_cast< wxSize * >(argp1);
5208 {
5209 result = (int)((wxSize const *)arg1)->GetWidth();
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 resultobj = SWIG_From_int(static_cast< int >(result));
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5220 PyObject *resultobj = 0;
5221 wxSize *arg1 = (wxSize *) 0 ;
5222 int result;
5223 void *argp1 = 0 ;
5224 int res1 = 0 ;
5225 PyObject *swig_obj[1] ;
5226
5227 if (!args) SWIG_fail;
5228 swig_obj[0] = args;
5229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5230 if (!SWIG_IsOK(res1)) {
5231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5232 }
5233 arg1 = reinterpret_cast< wxSize * >(argp1);
5234 {
5235 result = (int)((wxSize const *)arg1)->GetHeight();
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 resultobj = SWIG_From_int(static_cast< int >(result));
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5246 PyObject *resultobj = 0;
5247 wxSize *arg1 = (wxSize *) 0 ;
5248 bool result;
5249 void *argp1 = 0 ;
5250 int res1 = 0 ;
5251 PyObject *swig_obj[1] ;
5252
5253 if (!args) SWIG_fail;
5254 swig_obj[0] = args;
5255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5256 if (!SWIG_IsOK(res1)) {
5257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5258 }
5259 arg1 = reinterpret_cast< wxSize * >(argp1);
5260 {
5261 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 {
5265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5266 }
5267 return resultobj;
5268 fail:
5269 return NULL;
5270 }
5271
5272
5273 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5274 PyObject *resultobj = 0;
5275 wxSize *arg1 = (wxSize *) 0 ;
5276 wxSize *arg2 = 0 ;
5277 void *argp1 = 0 ;
5278 int res1 = 0 ;
5279 wxSize temp2 ;
5280 PyObject * obj0 = 0 ;
5281 PyObject * obj1 = 0 ;
5282 char * kwnames[] = {
5283 (char *) "self",(char *) "size", NULL
5284 };
5285
5286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5288 if (!SWIG_IsOK(res1)) {
5289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5290 }
5291 arg1 = reinterpret_cast< wxSize * >(argp1);
5292 {
5293 arg2 = &temp2;
5294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5295 }
5296 {
5297 (arg1)->SetDefaults((wxSize const &)*arg2);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 resultobj = SWIG_Py_Void();
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5308 PyObject *resultobj = 0;
5309 wxSize *arg1 = (wxSize *) 0 ;
5310 PyObject *result = 0 ;
5311 void *argp1 = 0 ;
5312 int res1 = 0 ;
5313 PyObject *swig_obj[1] ;
5314
5315 if (!args) SWIG_fail;
5316 swig_obj[0] = args;
5317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5318 if (!SWIG_IsOK(res1)) {
5319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5320 }
5321 arg1 = reinterpret_cast< wxSize * >(argp1);
5322 {
5323 result = (PyObject *)wxSize_Get(arg1);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = result;
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5334 PyObject *obj;
5335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5336 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5337 return SWIG_Py_Void();
5338 }
5339
5340 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5341 return SWIG_Python_InitShadowInstance(args);
5342 }
5343
5344 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *resultobj = 0;
5346 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5347 double arg2 ;
5348 void *argp1 = 0 ;
5349 int res1 = 0 ;
5350 double val2 ;
5351 int ecode2 = 0 ;
5352 PyObject *swig_obj[2] ;
5353
5354 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5356 if (!SWIG_IsOK(res1)) {
5357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5358 }
5359 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5360 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5361 if (!SWIG_IsOK(ecode2)) {
5362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5363 }
5364 arg2 = static_cast< double >(val2);
5365 if (arg1) (arg1)->x = arg2;
5366
5367 resultobj = SWIG_Py_Void();
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5375 PyObject *resultobj = 0;
5376 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5377 double result;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 PyObject *swig_obj[1] ;
5381
5382 if (!args) SWIG_fail;
5383 swig_obj[0] = args;
5384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5385 if (!SWIG_IsOK(res1)) {
5386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5387 }
5388 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5389 result = (double) ((arg1)->x);
5390 resultobj = SWIG_From_double(static_cast< double >(result));
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5398 PyObject *resultobj = 0;
5399 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5400 double arg2 ;
5401 void *argp1 = 0 ;
5402 int res1 = 0 ;
5403 double val2 ;
5404 int ecode2 = 0 ;
5405 PyObject *swig_obj[2] ;
5406
5407 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5409 if (!SWIG_IsOK(res1)) {
5410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5411 }
5412 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5413 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5414 if (!SWIG_IsOK(ecode2)) {
5415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5416 }
5417 arg2 = static_cast< double >(val2);
5418 if (arg1) (arg1)->y = arg2;
5419
5420 resultobj = SWIG_Py_Void();
5421 return resultobj;
5422 fail:
5423 return NULL;
5424 }
5425
5426
5427 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5428 PyObject *resultobj = 0;
5429 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5430 double result;
5431 void *argp1 = 0 ;
5432 int res1 = 0 ;
5433 PyObject *swig_obj[1] ;
5434
5435 if (!args) SWIG_fail;
5436 swig_obj[0] = args;
5437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5438 if (!SWIG_IsOK(res1)) {
5439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5440 }
5441 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5442 result = (double) ((arg1)->y);
5443 resultobj = SWIG_From_double(static_cast< double >(result));
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj = 0;
5452 double arg1 = (double) 0.0 ;
5453 double arg2 = (double) 0.0 ;
5454 wxRealPoint *result = 0 ;
5455 double val1 ;
5456 int ecode1 = 0 ;
5457 double val2 ;
5458 int ecode2 = 0 ;
5459 PyObject * obj0 = 0 ;
5460 PyObject * obj1 = 0 ;
5461 char * kwnames[] = {
5462 (char *) "x",(char *) "y", NULL
5463 };
5464
5465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5466 if (obj0) {
5467 ecode1 = SWIG_AsVal_double(obj0, &val1);
5468 if (!SWIG_IsOK(ecode1)) {
5469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5470 }
5471 arg1 = static_cast< double >(val1);
5472 }
5473 if (obj1) {
5474 ecode2 = SWIG_AsVal_double(obj1, &val2);
5475 if (!SWIG_IsOK(ecode2)) {
5476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5477 }
5478 arg2 = static_cast< double >(val2);
5479 }
5480 {
5481 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5482 if (PyErr_Occurred()) SWIG_fail;
5483 }
5484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5492 PyObject *resultobj = 0;
5493 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5494 void *argp1 = 0 ;
5495 int res1 = 0 ;
5496 PyObject *swig_obj[1] ;
5497
5498 if (!args) SWIG_fail;
5499 swig_obj[0] = args;
5500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5501 if (!SWIG_IsOK(res1)) {
5502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5503 }
5504 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5505 {
5506 delete arg1;
5507
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_Py_Void();
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5520 PyObject *arg2 = (PyObject *) 0 ;
5521 bool result;
5522 void *argp1 = 0 ;
5523 int res1 = 0 ;
5524 PyObject * obj0 = 0 ;
5525 PyObject * obj1 = 0 ;
5526 char * kwnames[] = {
5527 (char *) "self",(char *) "other", NULL
5528 };
5529
5530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5532 if (!SWIG_IsOK(res1)) {
5533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5534 }
5535 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5536 arg2 = obj1;
5537 {
5538 result = (bool)wxRealPoint___eq__(arg1,arg2);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj = 0;
5552 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5553 PyObject *arg2 = (PyObject *) 0 ;
5554 bool result;
5555 void *argp1 = 0 ;
5556 int res1 = 0 ;
5557 PyObject * obj0 = 0 ;
5558 PyObject * obj1 = 0 ;
5559 char * kwnames[] = {
5560 (char *) "self",(char *) "other", NULL
5561 };
5562
5563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5565 if (!SWIG_IsOK(res1)) {
5566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5567 }
5568 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5569 arg2 = obj1;
5570 {
5571 result = (bool)wxRealPoint___ne__(arg1,arg2);
5572 if (PyErr_Occurred()) SWIG_fail;
5573 }
5574 {
5575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj = 0;
5585 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5586 wxRealPoint *arg2 = 0 ;
5587 wxRealPoint result;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 wxRealPoint temp2 ;
5591 PyObject * obj0 = 0 ;
5592 PyObject * obj1 = 0 ;
5593 char * kwnames[] = {
5594 (char *) "self",(char *) "pt", NULL
5595 };
5596
5597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5599 if (!SWIG_IsOK(res1)) {
5600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5601 }
5602 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5603 {
5604 arg2 = &temp2;
5605 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5606 }
5607 {
5608 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5619 PyObject *resultobj = 0;
5620 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5621 wxRealPoint *arg2 = 0 ;
5622 wxRealPoint result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 wxRealPoint temp2 ;
5626 PyObject * obj0 = 0 ;
5627 PyObject * obj1 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "pt", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 {
5639 arg2 = &temp2;
5640 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5641 }
5642 {
5643 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5644 if (PyErr_Occurred()) SWIG_fail;
5645 }
5646 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5647 return resultobj;
5648 fail:
5649 return NULL;
5650 }
5651
5652
5653 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5654 PyObject *resultobj = 0;
5655 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5656 double arg2 ;
5657 double arg3 ;
5658 void *argp1 = 0 ;
5659 int res1 = 0 ;
5660 double val2 ;
5661 int ecode2 = 0 ;
5662 double val3 ;
5663 int ecode3 = 0 ;
5664 PyObject * obj0 = 0 ;
5665 PyObject * obj1 = 0 ;
5666 PyObject * obj2 = 0 ;
5667 char * kwnames[] = {
5668 (char *) "self",(char *) "x",(char *) "y", NULL
5669 };
5670
5671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5673 if (!SWIG_IsOK(res1)) {
5674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5675 }
5676 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5677 ecode2 = SWIG_AsVal_double(obj1, &val2);
5678 if (!SWIG_IsOK(ecode2)) {
5679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5680 }
5681 arg2 = static_cast< double >(val2);
5682 ecode3 = SWIG_AsVal_double(obj2, &val3);
5683 if (!SWIG_IsOK(ecode3)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5685 }
5686 arg3 = static_cast< double >(val3);
5687 {
5688 wxRealPoint_Set(arg1,arg2,arg3);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_Py_Void();
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5699 PyObject *resultobj = 0;
5700 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5701 PyObject *result = 0 ;
5702 void *argp1 = 0 ;
5703 int res1 = 0 ;
5704 PyObject *swig_obj[1] ;
5705
5706 if (!args) SWIG_fail;
5707 swig_obj[0] = args;
5708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5709 if (!SWIG_IsOK(res1)) {
5710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5711 }
5712 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5713 {
5714 result = (PyObject *)wxRealPoint_Get(arg1);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 resultobj = result;
5718 return resultobj;
5719 fail:
5720 return NULL;
5721 }
5722
5723
5724 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725 PyObject *obj;
5726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5727 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5728 return SWIG_Py_Void();
5729 }
5730
5731 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5732 return SWIG_Python_InitShadowInstance(args);
5733 }
5734
5735 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 int arg2 ;
5739 void *argp1 = 0 ;
5740 int res1 = 0 ;
5741 int val2 ;
5742 int ecode2 = 0 ;
5743 PyObject *swig_obj[2] ;
5744
5745 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5752 if (!SWIG_IsOK(ecode2)) {
5753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5754 }
5755 arg2 = static_cast< int >(val2);
5756 if (arg1) (arg1)->x = arg2;
5757
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 int result;
5769 void *argp1 = 0 ;
5770 int res1 = 0 ;
5771 PyObject *swig_obj[1] ;
5772
5773 if (!args) SWIG_fail;
5774 swig_obj[0] = args;
5775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 result = (int) ((arg1)->x);
5781 resultobj = SWIG_From_int(static_cast< int >(result));
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5789 PyObject *resultobj = 0;
5790 wxPoint *arg1 = (wxPoint *) 0 ;
5791 int arg2 ;
5792 void *argp1 = 0 ;
5793 int res1 = 0 ;
5794 int val2 ;
5795 int ecode2 = 0 ;
5796 PyObject *swig_obj[2] ;
5797
5798 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5800 if (!SWIG_IsOK(res1)) {
5801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5802 }
5803 arg1 = reinterpret_cast< wxPoint * >(argp1);
5804 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5805 if (!SWIG_IsOK(ecode2)) {
5806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5807 }
5808 arg2 = static_cast< int >(val2);
5809 if (arg1) (arg1)->y = arg2;
5810
5811 resultobj = SWIG_Py_Void();
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5819 PyObject *resultobj = 0;
5820 wxPoint *arg1 = (wxPoint *) 0 ;
5821 int result;
5822 void *argp1 = 0 ;
5823 int res1 = 0 ;
5824 PyObject *swig_obj[1] ;
5825
5826 if (!args) SWIG_fail;
5827 swig_obj[0] = args;
5828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 result = (int) ((arg1)->y);
5834 resultobj = SWIG_From_int(static_cast< int >(result));
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj = 0;
5843 int arg1 = (int) 0 ;
5844 int arg2 = (int) 0 ;
5845 wxPoint *result = 0 ;
5846 int val1 ;
5847 int ecode1 = 0 ;
5848 int val2 ;
5849 int ecode2 = 0 ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 char * kwnames[] = {
5853 (char *) "x",(char *) "y", NULL
5854 };
5855
5856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5857 if (obj0) {
5858 ecode1 = SWIG_AsVal_int(obj0, &val1);
5859 if (!SWIG_IsOK(ecode1)) {
5860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5861 }
5862 arg1 = static_cast< int >(val1);
5863 }
5864 if (obj1) {
5865 ecode2 = SWIG_AsVal_int(obj1, &val2);
5866 if (!SWIG_IsOK(ecode2)) {
5867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5868 }
5869 arg2 = static_cast< int >(val2);
5870 }
5871 {
5872 result = (wxPoint *)new wxPoint(arg1,arg2);
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5883 PyObject *resultobj = 0;
5884 wxPoint *arg1 = (wxPoint *) 0 ;
5885 void *argp1 = 0 ;
5886 int res1 = 0 ;
5887 PyObject *swig_obj[1] ;
5888
5889 if (!args) SWIG_fail;
5890 swig_obj[0] = args;
5891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 {
5897 delete arg1;
5898
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 resultobj = SWIG_Py_Void();
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj = 0;
5910 wxPoint *arg1 = (wxPoint *) 0 ;
5911 PyObject *arg2 = (PyObject *) 0 ;
5912 bool result;
5913 void *argp1 = 0 ;
5914 int res1 = 0 ;
5915 PyObject * obj0 = 0 ;
5916 PyObject * obj1 = 0 ;
5917 char * kwnames[] = {
5918 (char *) "self",(char *) "other", NULL
5919 };
5920
5921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5923 if (!SWIG_IsOK(res1)) {
5924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5925 }
5926 arg1 = reinterpret_cast< wxPoint * >(argp1);
5927 arg2 = obj1;
5928 {
5929 result = (bool)wxPoint___eq__(arg1,arg2);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 {
5933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5934 }
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxPoint *arg1 = (wxPoint *) 0 ;
5944 PyObject *arg2 = (PyObject *) 0 ;
5945 bool result;
5946 void *argp1 = 0 ;
5947 int res1 = 0 ;
5948 PyObject * obj0 = 0 ;
5949 PyObject * obj1 = 0 ;
5950 char * kwnames[] = {
5951 (char *) "self",(char *) "other", NULL
5952 };
5953
5954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5958 }
5959 arg1 = reinterpret_cast< wxPoint * >(argp1);
5960 arg2 = obj1;
5961 {
5962 result = (bool)wxPoint___ne__(arg1,arg2);
5963 if (PyErr_Occurred()) SWIG_fail;
5964 }
5965 {
5966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj = 0;
5976 wxPoint *arg1 = (wxPoint *) 0 ;
5977 wxPoint *arg2 = 0 ;
5978 wxPoint result;
5979 void *argp1 = 0 ;
5980 int res1 = 0 ;
5981 wxPoint temp2 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 char * kwnames[] = {
5985 (char *) "self",(char *) "pt", NULL
5986 };
5987
5988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5990 if (!SWIG_IsOK(res1)) {
5991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5992 }
5993 arg1 = reinterpret_cast< wxPoint * >(argp1);
5994 {
5995 arg2 = &temp2;
5996 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5997 }
5998 {
5999 result = (arg1)->operator +((wxPoint const &)*arg2);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj = 0;
6011 wxPoint *arg1 = (wxPoint *) 0 ;
6012 wxPoint *arg2 = 0 ;
6013 wxPoint result;
6014 void *argp1 = 0 ;
6015 int res1 = 0 ;
6016 wxPoint temp2 ;
6017 PyObject * obj0 = 0 ;
6018 PyObject * obj1 = 0 ;
6019 char * kwnames[] = {
6020 (char *) "self",(char *) "pt", NULL
6021 };
6022
6023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6025 if (!SWIG_IsOK(res1)) {
6026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6027 }
6028 arg1 = reinterpret_cast< wxPoint * >(argp1);
6029 {
6030 arg2 = &temp2;
6031 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6032 }
6033 {
6034 result = (arg1)->operator -((wxPoint const &)*arg2);
6035 if (PyErr_Occurred()) SWIG_fail;
6036 }
6037 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6038 return resultobj;
6039 fail:
6040 return NULL;
6041 }
6042
6043
6044 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6045 PyObject *resultobj = 0;
6046 wxPoint *arg1 = (wxPoint *) 0 ;
6047 wxPoint *arg2 = 0 ;
6048 wxPoint *result = 0 ;
6049 void *argp1 = 0 ;
6050 int res1 = 0 ;
6051 wxPoint temp2 ;
6052 PyObject * obj0 = 0 ;
6053 PyObject * obj1 = 0 ;
6054 char * kwnames[] = {
6055 (char *) "self",(char *) "pt", NULL
6056 };
6057
6058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6060 if (!SWIG_IsOK(res1)) {
6061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6062 }
6063 arg1 = reinterpret_cast< wxPoint * >(argp1);
6064 {
6065 arg2 = &temp2;
6066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6067 }
6068 {
6069 {
6070 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6071 result = (wxPoint *) &_result_ref;
6072 }
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj = 0;
6084 wxPoint *arg1 = (wxPoint *) 0 ;
6085 wxPoint *arg2 = 0 ;
6086 wxPoint *result = 0 ;
6087 void *argp1 = 0 ;
6088 int res1 = 0 ;
6089 wxPoint temp2 ;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 char * kwnames[] = {
6093 (char *) "self",(char *) "pt", NULL
6094 };
6095
6096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6098 if (!SWIG_IsOK(res1)) {
6099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6100 }
6101 arg1 = reinterpret_cast< wxPoint * >(argp1);
6102 {
6103 arg2 = &temp2;
6104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6105 }
6106 {
6107 {
6108 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6109 result = (wxPoint *) &_result_ref;
6110 }
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxPoint *arg1 = (wxPoint *) 0 ;
6123 long arg2 ;
6124 long arg3 ;
6125 void *argp1 = 0 ;
6126 int res1 = 0 ;
6127 long val2 ;
6128 int ecode2 = 0 ;
6129 long val3 ;
6130 int ecode3 = 0 ;
6131 PyObject * obj0 = 0 ;
6132 PyObject * obj1 = 0 ;
6133 PyObject * obj2 = 0 ;
6134 char * kwnames[] = {
6135 (char *) "self",(char *) "x",(char *) "y", NULL
6136 };
6137
6138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6140 if (!SWIG_IsOK(res1)) {
6141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6142 }
6143 arg1 = reinterpret_cast< wxPoint * >(argp1);
6144 ecode2 = SWIG_AsVal_long(obj1, &val2);
6145 if (!SWIG_IsOK(ecode2)) {
6146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6147 }
6148 arg2 = static_cast< long >(val2);
6149 ecode3 = SWIG_AsVal_long(obj2, &val3);
6150 if (!SWIG_IsOK(ecode3)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6152 }
6153 arg3 = static_cast< long >(val3);
6154 {
6155 wxPoint_Set(arg1,arg2,arg3);
6156 if (PyErr_Occurred()) SWIG_fail;
6157 }
6158 resultobj = SWIG_Py_Void();
6159 return resultobj;
6160 fail:
6161 return NULL;
6162 }
6163
6164
6165 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6166 PyObject *resultobj = 0;
6167 wxPoint *arg1 = (wxPoint *) 0 ;
6168 PyObject *result = 0 ;
6169 void *argp1 = 0 ;
6170 int res1 = 0 ;
6171 PyObject *swig_obj[1] ;
6172
6173 if (!args) SWIG_fail;
6174 swig_obj[0] = args;
6175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6176 if (!SWIG_IsOK(res1)) {
6177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6178 }
6179 arg1 = reinterpret_cast< wxPoint * >(argp1);
6180 {
6181 result = (PyObject *)wxPoint_Get(arg1);
6182 if (PyErr_Occurred()) SWIG_fail;
6183 }
6184 resultobj = result;
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6192 PyObject *obj;
6193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6194 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6195 return SWIG_Py_Void();
6196 }
6197
6198 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6199 return SWIG_Python_InitShadowInstance(args);
6200 }
6201
6202 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj = 0;
6204 int arg1 = (int) 0 ;
6205 int arg2 = (int) 0 ;
6206 int arg3 = (int) 0 ;
6207 int arg4 = (int) 0 ;
6208 wxRect *result = 0 ;
6209 int val1 ;
6210 int ecode1 = 0 ;
6211 int val2 ;
6212 int ecode2 = 0 ;
6213 int val3 ;
6214 int ecode3 = 0 ;
6215 int val4 ;
6216 int ecode4 = 0 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 PyObject * obj3 = 0 ;
6221 char * kwnames[] = {
6222 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6223 };
6224
6225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6226 if (obj0) {
6227 ecode1 = SWIG_AsVal_int(obj0, &val1);
6228 if (!SWIG_IsOK(ecode1)) {
6229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6230 }
6231 arg1 = static_cast< int >(val1);
6232 }
6233 if (obj1) {
6234 ecode2 = SWIG_AsVal_int(obj1, &val2);
6235 if (!SWIG_IsOK(ecode2)) {
6236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6237 }
6238 arg2 = static_cast< int >(val2);
6239 }
6240 if (obj2) {
6241 ecode3 = SWIG_AsVal_int(obj2, &val3);
6242 if (!SWIG_IsOK(ecode3)) {
6243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6244 }
6245 arg3 = static_cast< int >(val3);
6246 }
6247 if (obj3) {
6248 ecode4 = SWIG_AsVal_int(obj3, &val4);
6249 if (!SWIG_IsOK(ecode4)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6251 }
6252 arg4 = static_cast< int >(val4);
6253 }
6254 {
6255 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxPoint *arg1 = 0 ;
6268 wxPoint *arg2 = 0 ;
6269 wxRect *result = 0 ;
6270 wxPoint temp1 ;
6271 wxPoint temp2 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char * kwnames[] = {
6275 (char *) "topLeft",(char *) "bottomRight", NULL
6276 };
6277
6278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6279 {
6280 arg1 = &temp1;
6281 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6282 }
6283 {
6284 arg2 = &temp2;
6285 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6286 }
6287 {
6288 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6289 if (PyErr_Occurred()) SWIG_fail;
6290 }
6291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6292 return resultobj;
6293 fail:
6294 return NULL;
6295 }
6296
6297
6298 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6299 PyObject *resultobj = 0;
6300 wxPoint *arg1 = 0 ;
6301 wxSize *arg2 = 0 ;
6302 wxRect *result = 0 ;
6303 wxPoint temp1 ;
6304 wxSize temp2 ;
6305 PyObject * obj0 = 0 ;
6306 PyObject * obj1 = 0 ;
6307 char * kwnames[] = {
6308 (char *) "pos",(char *) "size", NULL
6309 };
6310
6311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6312 {
6313 arg1 = &temp1;
6314 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6315 }
6316 {
6317 arg2 = &temp2;
6318 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6319 }
6320 {
6321 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6322 if (PyErr_Occurred()) SWIG_fail;
6323 }
6324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj = 0;
6333 wxSize *arg1 = 0 ;
6334 wxRect *result = 0 ;
6335 wxSize temp1 ;
6336 PyObject * obj0 = 0 ;
6337 char * kwnames[] = {
6338 (char *) "size", NULL
6339 };
6340
6341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6342 {
6343 arg1 = &temp1;
6344 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6345 }
6346 {
6347 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6358 PyObject *resultobj = 0;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 PyObject *swig_obj[1] ;
6363
6364 if (!args) SWIG_fail;
6365 swig_obj[0] = args;
6366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 {
6372 delete arg1;
6373
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 resultobj = SWIG_Py_Void();
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6384 PyObject *resultobj = 0;
6385 wxRect *arg1 = (wxRect *) 0 ;
6386 int result;
6387 void *argp1 = 0 ;
6388 int res1 = 0 ;
6389 PyObject *swig_obj[1] ;
6390
6391 if (!args) SWIG_fail;
6392 swig_obj[0] = args;
6393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6394 if (!SWIG_IsOK(res1)) {
6395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6396 }
6397 arg1 = reinterpret_cast< wxRect * >(argp1);
6398 {
6399 result = (int)((wxRect const *)arg1)->GetX();
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_From_int(static_cast< int >(result));
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int arg2 ;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 int val2 ;
6416 int ecode2 = 0 ;
6417 PyObject * obj0 = 0 ;
6418 PyObject * obj1 = 0 ;
6419 char * kwnames[] = {
6420 (char *) "self",(char *) "x", NULL
6421 };
6422
6423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6425 if (!SWIG_IsOK(res1)) {
6426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6427 }
6428 arg1 = reinterpret_cast< wxRect * >(argp1);
6429 ecode2 = SWIG_AsVal_int(obj1, &val2);
6430 if (!SWIG_IsOK(ecode2)) {
6431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6432 }
6433 arg2 = static_cast< int >(val2);
6434 {
6435 (arg1)->SetX(arg2);
6436 if (PyErr_Occurred()) SWIG_fail;
6437 }
6438 resultobj = SWIG_Py_Void();
6439 return resultobj;
6440 fail:
6441 return NULL;
6442 }
6443
6444
6445 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6446 PyObject *resultobj = 0;
6447 wxRect *arg1 = (wxRect *) 0 ;
6448 int result;
6449 void *argp1 = 0 ;
6450 int res1 = 0 ;
6451 PyObject *swig_obj[1] ;
6452
6453 if (!args) SWIG_fail;
6454 swig_obj[0] = args;
6455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6456 if (!SWIG_IsOK(res1)) {
6457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6458 }
6459 arg1 = reinterpret_cast< wxRect * >(argp1);
6460 {
6461 result = (int)(arg1)->GetY();
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = SWIG_From_int(static_cast< int >(result));
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj = 0;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 int arg2 ;
6475 void *argp1 = 0 ;
6476 int res1 = 0 ;
6477 int val2 ;
6478 int ecode2 = 0 ;
6479 PyObject * obj0 = 0 ;
6480 PyObject * obj1 = 0 ;
6481 char * kwnames[] = {
6482 (char *) "self",(char *) "y", NULL
6483 };
6484
6485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 ecode2 = SWIG_AsVal_int(obj1, &val2);
6492 if (!SWIG_IsOK(ecode2)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6494 }
6495 arg2 = static_cast< int >(val2);
6496 {
6497 (arg1)->SetY(arg2);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_Py_Void();
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6508 PyObject *resultobj = 0;
6509 wxRect *arg1 = (wxRect *) 0 ;
6510 int result;
6511 void *argp1 = 0 ;
6512 int res1 = 0 ;
6513 PyObject *swig_obj[1] ;
6514
6515 if (!args) SWIG_fail;
6516 swig_obj[0] = args;
6517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6518 if (!SWIG_IsOK(res1)) {
6519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6520 }
6521 arg1 = reinterpret_cast< wxRect * >(argp1);
6522 {
6523 result = (int)((wxRect const *)arg1)->GetWidth();
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj = 0;
6535 wxRect *arg1 = (wxRect *) 0 ;
6536 int arg2 ;
6537 void *argp1 = 0 ;
6538 int res1 = 0 ;
6539 int val2 ;
6540 int ecode2 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "w", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 ecode2 = SWIG_AsVal_int(obj1, &val2);
6554 if (!SWIG_IsOK(ecode2)) {
6555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6556 }
6557 arg2 = static_cast< int >(val2);
6558 {
6559 (arg1)->SetWidth(arg2);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_Py_Void();
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 int result;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 PyObject *swig_obj[1] ;
6576
6577 if (!args) SWIG_fail;
6578 swig_obj[0] = args;
6579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6580 if (!SWIG_IsOK(res1)) {
6581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6582 }
6583 arg1 = reinterpret_cast< wxRect * >(argp1);
6584 {
6585 result = (int)((wxRect const *)arg1)->GetHeight();
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_From_int(static_cast< int >(result));
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj = 0;
6597 wxRect *arg1 = (wxRect *) 0 ;
6598 int arg2 ;
6599 void *argp1 = 0 ;
6600 int res1 = 0 ;
6601 int val2 ;
6602 int ecode2 = 0 ;
6603 PyObject * obj0 = 0 ;
6604 PyObject * obj1 = 0 ;
6605 char * kwnames[] = {
6606 (char *) "self",(char *) "h", NULL
6607 };
6608
6609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6611 if (!SWIG_IsOK(res1)) {
6612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6613 }
6614 arg1 = reinterpret_cast< wxRect * >(argp1);
6615 ecode2 = SWIG_AsVal_int(obj1, &val2);
6616 if (!SWIG_IsOK(ecode2)) {
6617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6618 }
6619 arg2 = static_cast< int >(val2);
6620 {
6621 (arg1)->SetHeight(arg2);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 resultobj = SWIG_Py_Void();
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632 PyObject *resultobj = 0;
6633 wxRect *arg1 = (wxRect *) 0 ;
6634 wxPoint result;
6635 void *argp1 = 0 ;
6636 int res1 = 0 ;
6637 PyObject *swig_obj[1] ;
6638
6639 if (!args) SWIG_fail;
6640 swig_obj[0] = args;
6641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6642 if (!SWIG_IsOK(res1)) {
6643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6644 }
6645 arg1 = reinterpret_cast< wxRect * >(argp1);
6646 {
6647 result = ((wxRect const *)arg1)->GetPosition();
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 wxPoint *arg2 = 0 ;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 wxPoint temp2 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char * kwnames[] = {
6667 (char *) "self",(char *) "p", NULL
6668 };
6669
6670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6672 if (!SWIG_IsOK(res1)) {
6673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6674 }
6675 arg1 = reinterpret_cast< wxRect * >(argp1);
6676 {
6677 arg2 = &temp2;
6678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6679 }
6680 {
6681 (arg1)->SetPosition((wxPoint const &)*arg2);
6682 if (PyErr_Occurred()) SWIG_fail;
6683 }
6684 resultobj = SWIG_Py_Void();
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6692 PyObject *resultobj = 0;
6693 wxRect *arg1 = (wxRect *) 0 ;
6694 wxSize result;
6695 void *argp1 = 0 ;
6696 int res1 = 0 ;
6697 PyObject *swig_obj[1] ;
6698
6699 if (!args) SWIG_fail;
6700 swig_obj[0] = args;
6701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6702 if (!SWIG_IsOK(res1)) {
6703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6704 }
6705 arg1 = reinterpret_cast< wxRect * >(argp1);
6706 {
6707 result = ((wxRect const *)arg1)->GetSize();
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6718 PyObject *resultobj = 0;
6719 wxRect *arg1 = (wxRect *) 0 ;
6720 wxSize *arg2 = 0 ;
6721 void *argp1 = 0 ;
6722 int res1 = 0 ;
6723 wxSize temp2 ;
6724 PyObject * obj0 = 0 ;
6725 PyObject * obj1 = 0 ;
6726 char * kwnames[] = {
6727 (char *) "self",(char *) "s", NULL
6728 };
6729
6730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6732 if (!SWIG_IsOK(res1)) {
6733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6734 }
6735 arg1 = reinterpret_cast< wxRect * >(argp1);
6736 {
6737 arg2 = &temp2;
6738 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6739 }
6740 {
6741 (arg1)->SetSize((wxSize const &)*arg2);
6742 if (PyErr_Occurred()) SWIG_fail;
6743 }
6744 resultobj = SWIG_Py_Void();
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6752 PyObject *resultobj = 0;
6753 wxRect *arg1 = (wxRect *) 0 ;
6754 bool result;
6755 void *argp1 = 0 ;
6756 int res1 = 0 ;
6757 PyObject *swig_obj[1] ;
6758
6759 if (!args) SWIG_fail;
6760 swig_obj[0] = args;
6761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6762 if (!SWIG_IsOK(res1)) {
6763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6764 }
6765 arg1 = reinterpret_cast< wxRect * >(argp1);
6766 {
6767 result = (bool)((wxRect const *)arg1)->IsEmpty();
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 wxRect *arg1 = (wxRect *) 0 ;
6782 wxPoint result;
6783 void *argp1 = 0 ;
6784 int res1 = 0 ;
6785 PyObject *swig_obj[1] ;
6786
6787 if (!args) SWIG_fail;
6788 swig_obj[0] = args;
6789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6790 if (!SWIG_IsOK(res1)) {
6791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6792 }
6793 arg1 = reinterpret_cast< wxRect * >(argp1);
6794 {
6795 result = ((wxRect const *)arg1)->GetTopLeft();
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj = 0;
6807 wxRect *arg1 = (wxRect *) 0 ;
6808 wxPoint *arg2 = 0 ;
6809 void *argp1 = 0 ;
6810 int res1 = 0 ;
6811 wxPoint temp2 ;
6812 PyObject * obj0 = 0 ;
6813 PyObject * obj1 = 0 ;
6814 char * kwnames[] = {
6815 (char *) "self",(char *) "p", NULL
6816 };
6817
6818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6820 if (!SWIG_IsOK(res1)) {
6821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6822 }
6823 arg1 = reinterpret_cast< wxRect * >(argp1);
6824 {
6825 arg2 = &temp2;
6826 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6827 }
6828 {
6829 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6830 if (PyErr_Occurred()) SWIG_fail;
6831 }
6832 resultobj = SWIG_Py_Void();
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6840 PyObject *resultobj = 0;
6841 wxRect *arg1 = (wxRect *) 0 ;
6842 wxPoint result;
6843 void *argp1 = 0 ;
6844 int res1 = 0 ;
6845 PyObject *swig_obj[1] ;
6846
6847 if (!args) SWIG_fail;
6848 swig_obj[0] = args;
6849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6850 if (!SWIG_IsOK(res1)) {
6851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6852 }
6853 arg1 = reinterpret_cast< wxRect * >(argp1);
6854 {
6855 result = ((wxRect const *)arg1)->GetBottomRight();
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj = 0;
6867 wxRect *arg1 = (wxRect *) 0 ;
6868 wxPoint *arg2 = 0 ;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 wxPoint temp2 ;
6872 PyObject * obj0 = 0 ;
6873 PyObject * obj1 = 0 ;
6874 char * kwnames[] = {
6875 (char *) "self",(char *) "p", NULL
6876 };
6877
6878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6880 if (!SWIG_IsOK(res1)) {
6881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6882 }
6883 arg1 = reinterpret_cast< wxRect * >(argp1);
6884 {
6885 arg2 = &temp2;
6886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6887 }
6888 {
6889 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 resultobj = SWIG_Py_Void();
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6900 PyObject *resultobj = 0;
6901 wxRect *arg1 = (wxRect *) 0 ;
6902 wxPoint result;
6903 void *argp1 = 0 ;
6904 int res1 = 0 ;
6905 PyObject *swig_obj[1] ;
6906
6907 if (!args) SWIG_fail;
6908 swig_obj[0] = args;
6909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6910 if (!SWIG_IsOK(res1)) {
6911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6912 }
6913 arg1 = reinterpret_cast< wxRect * >(argp1);
6914 {
6915 result = ((wxRect const *)arg1)->GetTopRight();
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj = 0;
6927 wxRect *arg1 = (wxRect *) 0 ;
6928 wxPoint *arg2 = 0 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 wxPoint temp2 ;
6932 PyObject * obj0 = 0 ;
6933 PyObject * obj1 = 0 ;
6934 char * kwnames[] = {
6935 (char *) "self",(char *) "p", NULL
6936 };
6937
6938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6940 if (!SWIG_IsOK(res1)) {
6941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6942 }
6943 arg1 = reinterpret_cast< wxRect * >(argp1);
6944 {
6945 arg2 = &temp2;
6946 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6947 }
6948 {
6949 (arg1)->SetTopRight((wxPoint const &)*arg2);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_Py_Void();
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6960 PyObject *resultobj = 0;
6961 wxRect *arg1 = (wxRect *) 0 ;
6962 wxPoint result;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 PyObject *swig_obj[1] ;
6966
6967 if (!args) SWIG_fail;
6968 swig_obj[0] = args;
6969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6970 if (!SWIG_IsOK(res1)) {
6971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6972 }
6973 arg1 = reinterpret_cast< wxRect * >(argp1);
6974 {
6975 result = ((wxRect const *)arg1)->GetBottomLeft();
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj = 0;
6987 wxRect *arg1 = (wxRect *) 0 ;
6988 wxPoint *arg2 = 0 ;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 wxPoint temp2 ;
6992 PyObject * obj0 = 0 ;
6993 PyObject * obj1 = 0 ;
6994 char * kwnames[] = {
6995 (char *) "self",(char *) "p", NULL
6996 };
6997
6998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7000 if (!SWIG_IsOK(res1)) {
7001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7002 }
7003 arg1 = reinterpret_cast< wxRect * >(argp1);
7004 {
7005 arg2 = &temp2;
7006 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7007 }
7008 {
7009 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_Py_Void();
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7020 PyObject *resultobj = 0;
7021 wxRect *arg1 = (wxRect *) 0 ;
7022 int result;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 PyObject *swig_obj[1] ;
7026
7027 if (!args) SWIG_fail;
7028 swig_obj[0] = args;
7029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7032 }
7033 arg1 = reinterpret_cast< wxRect * >(argp1);
7034 {
7035 result = (int)((wxRect const *)arg1)->GetLeft();
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_From_int(static_cast< int >(result));
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 wxRect *arg1 = (wxRect *) 0 ;
7048 int result;
7049 void *argp1 = 0 ;
7050 int res1 = 0 ;
7051 PyObject *swig_obj[1] ;
7052
7053 if (!args) SWIG_fail;
7054 swig_obj[0] = args;
7055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7056 if (!SWIG_IsOK(res1)) {
7057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7058 }
7059 arg1 = reinterpret_cast< wxRect * >(argp1);
7060 {
7061 result = (int)((wxRect const *)arg1)->GetTop();
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_From_int(static_cast< int >(result));
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 int result;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 PyObject *swig_obj[1] ;
7078
7079 if (!args) SWIG_fail;
7080 swig_obj[0] = args;
7081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7082 if (!SWIG_IsOK(res1)) {
7083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7084 }
7085 arg1 = reinterpret_cast< wxRect * >(argp1);
7086 {
7087 result = (int)((wxRect const *)arg1)->GetBottom();
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_From_int(static_cast< int >(result));
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxRect *arg1 = (wxRect *) 0 ;
7100 int result;
7101 void *argp1 = 0 ;
7102 int res1 = 0 ;
7103 PyObject *swig_obj[1] ;
7104
7105 if (!args) SWIG_fail;
7106 swig_obj[0] = args;
7107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7108 if (!SWIG_IsOK(res1)) {
7109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7110 }
7111 arg1 = reinterpret_cast< wxRect * >(argp1);
7112 {
7113 result = (int)((wxRect const *)arg1)->GetRight();
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_From_int(static_cast< int >(result));
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 int val2 ;
7130 int ecode2 = 0 ;
7131 PyObject * obj0 = 0 ;
7132 PyObject * obj1 = 0 ;
7133 char * kwnames[] = {
7134 (char *) "self",(char *) "left", NULL
7135 };
7136
7137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7139 if (!SWIG_IsOK(res1)) {
7140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7141 }
7142 arg1 = reinterpret_cast< wxRect * >(argp1);
7143 ecode2 = SWIG_AsVal_int(obj1, &val2);
7144 if (!SWIG_IsOK(ecode2)) {
7145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7146 }
7147 arg2 = static_cast< int >(val2);
7148 {
7149 (arg1)->SetLeft(arg2);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 resultobj = SWIG_Py_Void();
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj = 0;
7161 wxRect *arg1 = (wxRect *) 0 ;
7162 int arg2 ;
7163 void *argp1 = 0 ;
7164 int res1 = 0 ;
7165 int val2 ;
7166 int ecode2 = 0 ;
7167 PyObject * obj0 = 0 ;
7168 PyObject * obj1 = 0 ;
7169 char * kwnames[] = {
7170 (char *) "self",(char *) "right", NULL
7171 };
7172
7173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7175 if (!SWIG_IsOK(res1)) {
7176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7177 }
7178 arg1 = reinterpret_cast< wxRect * >(argp1);
7179 ecode2 = SWIG_AsVal_int(obj1, &val2);
7180 if (!SWIG_IsOK(ecode2)) {
7181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7182 }
7183 arg2 = static_cast< int >(val2);
7184 {
7185 (arg1)->SetRight(arg2);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 resultobj = SWIG_Py_Void();
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj = 0;
7197 wxRect *arg1 = (wxRect *) 0 ;
7198 int arg2 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 PyObject * obj0 = 0 ;
7204 PyObject * obj1 = 0 ;
7205 char * kwnames[] = {
7206 (char *) "self",(char *) "top", NULL
7207 };
7208
7209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7211 if (!SWIG_IsOK(res1)) {
7212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7213 }
7214 arg1 = reinterpret_cast< wxRect * >(argp1);
7215 ecode2 = SWIG_AsVal_int(obj1, &val2);
7216 if (!SWIG_IsOK(ecode2)) {
7217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7218 }
7219 arg2 = static_cast< int >(val2);
7220 {
7221 (arg1)->SetTop(arg2);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 resultobj = SWIG_Py_Void();
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj = 0;
7233 wxRect *arg1 = (wxRect *) 0 ;
7234 int arg2 ;
7235 void *argp1 = 0 ;
7236 int res1 = 0 ;
7237 int val2 ;
7238 int ecode2 = 0 ;
7239 PyObject * obj0 = 0 ;
7240 PyObject * obj1 = 0 ;
7241 char * kwnames[] = {
7242 (char *) "self",(char *) "bottom", NULL
7243 };
7244
7245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7247 if (!SWIG_IsOK(res1)) {
7248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7249 }
7250 arg1 = reinterpret_cast< wxRect * >(argp1);
7251 ecode2 = SWIG_AsVal_int(obj1, &val2);
7252 if (!SWIG_IsOK(ecode2)) {
7253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7254 }
7255 arg2 = static_cast< int >(val2);
7256 {
7257 (arg1)->SetBottom(arg2);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 resultobj = SWIG_Py_Void();
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj = 0;
7269 wxRect *arg1 = (wxRect *) 0 ;
7270 int arg2 ;
7271 int arg3 ;
7272 wxRect *result = 0 ;
7273 void *argp1 = 0 ;
7274 int res1 = 0 ;
7275 int val2 ;
7276 int ecode2 = 0 ;
7277 int val3 ;
7278 int ecode3 = 0 ;
7279 PyObject * obj0 = 0 ;
7280 PyObject * obj1 = 0 ;
7281 PyObject * obj2 = 0 ;
7282 char * kwnames[] = {
7283 (char *) "self",(char *) "dx",(char *) "dy", NULL
7284 };
7285
7286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7288 if (!SWIG_IsOK(res1)) {
7289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7290 }
7291 arg1 = reinterpret_cast< wxRect * >(argp1);
7292 ecode2 = SWIG_AsVal_int(obj1, &val2);
7293 if (!SWIG_IsOK(ecode2)) {
7294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7295 }
7296 arg2 = static_cast< int >(val2);
7297 ecode3 = SWIG_AsVal_int(obj2, &val3);
7298 if (!SWIG_IsOK(ecode3)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7300 }
7301 arg3 = static_cast< int >(val3);
7302 {
7303 {
7304 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7305 result = (wxRect *) &_result_ref;
7306 }
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 int arg2 ;
7320 int arg3 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 int val2 ;
7325 int ecode2 = 0 ;
7326 int val3 ;
7327 int ecode3 = 0 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 PyObject * obj2 = 0 ;
7331 char * kwnames[] = {
7332 (char *) "self",(char *) "dx",(char *) "dy", NULL
7333 };
7334
7335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7337 if (!SWIG_IsOK(res1)) {
7338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7339 }
7340 arg1 = reinterpret_cast< wxRect * >(argp1);
7341 ecode2 = SWIG_AsVal_int(obj1, &val2);
7342 if (!SWIG_IsOK(ecode2)) {
7343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7344 }
7345 arg2 = static_cast< int >(val2);
7346 ecode3 = SWIG_AsVal_int(obj2, &val3);
7347 if (!SWIG_IsOK(ecode3)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7349 }
7350 arg3 = static_cast< int >(val3);
7351 {
7352 {
7353 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7354 result = (wxRect *) &_result_ref;
7355 }
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj = 0;
7367 wxRect *arg1 = (wxRect *) 0 ;
7368 int arg2 ;
7369 int arg3 ;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 int val2 ;
7373 int ecode2 = 0 ;
7374 int val3 ;
7375 int ecode3 = 0 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 PyObject * obj2 = 0 ;
7379 char * kwnames[] = {
7380 (char *) "self",(char *) "dx",(char *) "dy", NULL
7381 };
7382
7383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7387 }
7388 arg1 = reinterpret_cast< wxRect * >(argp1);
7389 ecode2 = SWIG_AsVal_int(obj1, &val2);
7390 if (!SWIG_IsOK(ecode2)) {
7391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7392 }
7393 arg2 = static_cast< int >(val2);
7394 ecode3 = SWIG_AsVal_int(obj2, &val3);
7395 if (!SWIG_IsOK(ecode3)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7397 }
7398 arg3 = static_cast< int >(val3);
7399 {
7400 (arg1)->Offset(arg2,arg3);
7401 if (PyErr_Occurred()) SWIG_fail;
7402 }
7403 resultobj = SWIG_Py_Void();
7404 return resultobj;
7405 fail:
7406 return NULL;
7407 }
7408
7409
7410 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7411 PyObject *resultobj = 0;
7412 wxRect *arg1 = (wxRect *) 0 ;
7413 wxPoint *arg2 = 0 ;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 wxPoint temp2 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char * kwnames[] = {
7420 (char *) "self",(char *) "pt", NULL
7421 };
7422
7423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7427 }
7428 arg1 = reinterpret_cast< wxRect * >(argp1);
7429 {
7430 arg2 = &temp2;
7431 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7432 }
7433 {
7434 (arg1)->Offset((wxPoint const &)*arg2);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 resultobj = SWIG_Py_Void();
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj = 0;
7446 wxRect *arg1 = (wxRect *) 0 ;
7447 wxRect *arg2 = 0 ;
7448 wxRect result;
7449 void *argp1 = 0 ;
7450 int res1 = 0 ;
7451 wxRect temp2 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "rect", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 {
7465 arg2 = &temp2;
7466 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7467 }
7468 {
7469 result = (arg1)->Intersect((wxRect const &)*arg2);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj = 0;
7481 wxRect *arg1 = (wxRect *) 0 ;
7482 wxRect *arg2 = 0 ;
7483 wxRect result;
7484 void *argp1 = 0 ;
7485 int res1 = 0 ;
7486 wxRect temp2 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "rect", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7497 }
7498 arg1 = reinterpret_cast< wxRect * >(argp1);
7499 {
7500 arg2 = &temp2;
7501 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7502 }
7503 {
7504 result = (arg1)->Union((wxRect const &)*arg2);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7515 PyObject *resultobj = 0;
7516 wxRect *arg1 = (wxRect *) 0 ;
7517 wxRect *arg2 = 0 ;
7518 wxRect result;
7519 void *argp1 = 0 ;
7520 int res1 = 0 ;
7521 wxRect temp2 ;
7522 PyObject * obj0 = 0 ;
7523 PyObject * obj1 = 0 ;
7524 char * kwnames[] = {
7525 (char *) "self",(char *) "rect", NULL
7526 };
7527
7528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7530 if (!SWIG_IsOK(res1)) {
7531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7532 }
7533 arg1 = reinterpret_cast< wxRect * >(argp1);
7534 {
7535 arg2 = &temp2;
7536 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7537 }
7538 {
7539 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj = 0;
7551 wxRect *arg1 = (wxRect *) 0 ;
7552 wxRect *arg2 = 0 ;
7553 wxRect *result = 0 ;
7554 void *argp1 = 0 ;
7555 int res1 = 0 ;
7556 wxRect temp2 ;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 char * kwnames[] = {
7560 (char *) "self",(char *) "rect", NULL
7561 };
7562
7563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7567 }
7568 arg1 = reinterpret_cast< wxRect * >(argp1);
7569 {
7570 arg2 = &temp2;
7571 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7572 }
7573 {
7574 {
7575 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7576 result = (wxRect *) &_result_ref;
7577 }
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = 0;
7589 wxRect *arg1 = (wxRect *) 0 ;
7590 PyObject *arg2 = (PyObject *) 0 ;
7591 bool result;
7592 void *argp1 = 0 ;
7593 int res1 = 0 ;
7594 PyObject * obj0 = 0 ;
7595 PyObject * obj1 = 0 ;
7596 char * kwnames[] = {
7597 (char *) "self",(char *) "other", NULL
7598 };
7599
7600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7602 if (!SWIG_IsOK(res1)) {
7603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7604 }
7605 arg1 = reinterpret_cast< wxRect * >(argp1);
7606 arg2 = obj1;
7607 {
7608 result = (bool)wxRect___eq__(arg1,arg2);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 {
7612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7613 }
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj = 0;
7622 wxRect *arg1 = (wxRect *) 0 ;
7623 PyObject *arg2 = (PyObject *) 0 ;
7624 bool result;
7625 void *argp1 = 0 ;
7626 int res1 = 0 ;
7627 PyObject * obj0 = 0 ;
7628 PyObject * obj1 = 0 ;
7629 char * kwnames[] = {
7630 (char *) "self",(char *) "other", NULL
7631 };
7632
7633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7635 if (!SWIG_IsOK(res1)) {
7636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7637 }
7638 arg1 = reinterpret_cast< wxRect * >(argp1);
7639 arg2 = obj1;
7640 {
7641 result = (bool)wxRect___ne__(arg1,arg2);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 {
7645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7646 }
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj = 0;
7655 wxRect *arg1 = (wxRect *) 0 ;
7656 int arg2 ;
7657 int arg3 ;
7658 bool result;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 int val2 ;
7662 int ecode2 = 0 ;
7663 int val3 ;
7664 int ecode3 = 0 ;
7665 PyObject * obj0 = 0 ;
7666 PyObject * obj1 = 0 ;
7667 PyObject * obj2 = 0 ;
7668 char * kwnames[] = {
7669 (char *) "self",(char *) "x",(char *) "y", NULL
7670 };
7671
7672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7674 if (!SWIG_IsOK(res1)) {
7675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7676 }
7677 arg1 = reinterpret_cast< wxRect * >(argp1);
7678 ecode2 = SWIG_AsVal_int(obj1, &val2);
7679 if (!SWIG_IsOK(ecode2)) {
7680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7681 }
7682 arg2 = static_cast< int >(val2);
7683 ecode3 = SWIG_AsVal_int(obj2, &val3);
7684 if (!SWIG_IsOK(ecode3)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7686 }
7687 arg3 = static_cast< int >(val3);
7688 {
7689 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7690 if (PyErr_Occurred()) SWIG_fail;
7691 }
7692 {
7693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7694 }
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7702 PyObject *resultobj = 0;
7703 wxRect *arg1 = (wxRect *) 0 ;
7704 wxPoint *arg2 = 0 ;
7705 bool result;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 wxPoint temp2 ;
7709 PyObject * obj0 = 0 ;
7710 PyObject * obj1 = 0 ;
7711 char * kwnames[] = {
7712 (char *) "self",(char *) "pt", NULL
7713 };
7714
7715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7719 }
7720 arg1 = reinterpret_cast< wxRect * >(argp1);
7721 {
7722 arg2 = &temp2;
7723 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7724 }
7725 {
7726 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 {
7730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7731 }
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 wxRect *arg2 = 0 ;
7742 bool result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 wxRect temp2 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 char * kwnames[] = {
7749 (char *) "self",(char *) "rect", NULL
7750 };
7751
7752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7756 }
7757 arg1 = reinterpret_cast< wxRect * >(argp1);
7758 {
7759 arg2 = &temp2;
7760 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7761 }
7762 {
7763 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7768 }
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj = 0;
7777 wxRect *arg1 = (wxRect *) 0 ;
7778 wxRect *arg2 = 0 ;
7779 bool result;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 wxRect temp2 ;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 char * kwnames[] = {
7786 (char *) "self",(char *) "rect", NULL
7787 };
7788
7789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7793 }
7794 arg1 = reinterpret_cast< wxRect * >(argp1);
7795 {
7796 arg2 = &temp2;
7797 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7798 }
7799 {
7800 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 {
7804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7805 }
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj = 0;
7814 wxRect *arg1 = (wxRect *) 0 ;
7815 wxRect *arg2 = 0 ;
7816 int arg3 = (int) wxBOTH ;
7817 wxRect result;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 wxRect temp2 ;
7821 int val3 ;
7822 int ecode3 = 0 ;
7823 PyObject * obj0 = 0 ;
7824 PyObject * obj1 = 0 ;
7825 PyObject * obj2 = 0 ;
7826 char * kwnames[] = {
7827 (char *) "self",(char *) "r",(char *) "dir", NULL
7828 };
7829
7830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7832 if (!SWIG_IsOK(res1)) {
7833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7834 }
7835 arg1 = reinterpret_cast< wxRect * >(argp1);
7836 {
7837 arg2 = &temp2;
7838 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7839 }
7840 if (obj2) {
7841 ecode3 = SWIG_AsVal_int(obj2, &val3);
7842 if (!SWIG_IsOK(ecode3)) {
7843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7844 }
7845 arg3 = static_cast< int >(val3);
7846 }
7847 {
7848 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7849 if (PyErr_Occurred()) SWIG_fail;
7850 }
7851 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7859 PyObject *resultobj = 0;
7860 wxRect *arg1 = (wxRect *) 0 ;
7861 int arg2 ;
7862 void *argp1 = 0 ;
7863 int res1 = 0 ;
7864 int val2 ;
7865 int ecode2 = 0 ;
7866 PyObject *swig_obj[2] ;
7867
7868 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
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_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7872 }
7873 arg1 = reinterpret_cast< wxRect * >(argp1);
7874 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7875 if (!SWIG_IsOK(ecode2)) {
7876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7877 }
7878 arg2 = static_cast< int >(val2);
7879 if (arg1) (arg1)->x = arg2;
7880
7881 resultobj = SWIG_Py_Void();
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7889 PyObject *resultobj = 0;
7890 wxRect *arg1 = (wxRect *) 0 ;
7891 int result;
7892 void *argp1 = 0 ;
7893 int res1 = 0 ;
7894 PyObject *swig_obj[1] ;
7895
7896 if (!args) SWIG_fail;
7897 swig_obj[0] = args;
7898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7899 if (!SWIG_IsOK(res1)) {
7900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7901 }
7902 arg1 = reinterpret_cast< wxRect * >(argp1);
7903 result = (int) ((arg1)->x);
7904 resultobj = SWIG_From_int(static_cast< int >(result));
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 PyObject *resultobj = 0;
7913 wxRect *arg1 = (wxRect *) 0 ;
7914 int arg2 ;
7915 void *argp1 = 0 ;
7916 int res1 = 0 ;
7917 int val2 ;
7918 int ecode2 = 0 ;
7919 PyObject *swig_obj[2] ;
7920
7921 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7923 if (!SWIG_IsOK(res1)) {
7924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7925 }
7926 arg1 = reinterpret_cast< wxRect * >(argp1);
7927 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7928 if (!SWIG_IsOK(ecode2)) {
7929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7930 }
7931 arg2 = static_cast< int >(val2);
7932 if (arg1) (arg1)->y = arg2;
7933
7934 resultobj = SWIG_Py_Void();
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7942 PyObject *resultobj = 0;
7943 wxRect *arg1 = (wxRect *) 0 ;
7944 int result;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 PyObject *swig_obj[1] ;
7948
7949 if (!args) SWIG_fail;
7950 swig_obj[0] = args;
7951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7952 if (!SWIG_IsOK(res1)) {
7953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7954 }
7955 arg1 = reinterpret_cast< wxRect * >(argp1);
7956 result = (int) ((arg1)->y);
7957 resultobj = SWIG_From_int(static_cast< int >(result));
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965 PyObject *resultobj = 0;
7966 wxRect *arg1 = (wxRect *) 0 ;
7967 int arg2 ;
7968 void *argp1 = 0 ;
7969 int res1 = 0 ;
7970 int val2 ;
7971 int ecode2 = 0 ;
7972 PyObject *swig_obj[2] ;
7973
7974 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7976 if (!SWIG_IsOK(res1)) {
7977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7978 }
7979 arg1 = reinterpret_cast< wxRect * >(argp1);
7980 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7981 if (!SWIG_IsOK(ecode2)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7983 }
7984 arg2 = static_cast< int >(val2);
7985 if (arg1) (arg1)->width = arg2;
7986
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 int result;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 result = (int) ((arg1)->width);
8010 resultobj = SWIG_From_int(static_cast< int >(result));
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 int arg2 ;
8021 void *argp1 = 0 ;
8022 int res1 = 0 ;
8023 int val2 ;
8024 int ecode2 = 0 ;
8025 PyObject *swig_obj[2] ;
8026
8027 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8029 if (!SWIG_IsOK(res1)) {
8030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8031 }
8032 arg1 = reinterpret_cast< wxRect * >(argp1);
8033 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8034 if (!SWIG_IsOK(ecode2)) {
8035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8036 }
8037 arg2 = static_cast< int >(val2);
8038 if (arg1) (arg1)->height = arg2;
8039
8040 resultobj = SWIG_Py_Void();
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049 wxRect *arg1 = (wxRect *) 0 ;
8050 int result;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 PyObject *swig_obj[1] ;
8054
8055 if (!args) SWIG_fail;
8056 swig_obj[0] = args;
8057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8058 if (!SWIG_IsOK(res1)) {
8059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8060 }
8061 arg1 = reinterpret_cast< wxRect * >(argp1);
8062 result = (int) ((arg1)->height);
8063 resultobj = SWIG_From_int(static_cast< int >(result));
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj = 0;
8072 wxRect *arg1 = (wxRect *) 0 ;
8073 int arg2 = (int) 0 ;
8074 int arg3 = (int) 0 ;
8075 int arg4 = (int) 0 ;
8076 int arg5 = (int) 0 ;
8077 void *argp1 = 0 ;
8078 int res1 = 0 ;
8079 int val2 ;
8080 int ecode2 = 0 ;
8081 int val3 ;
8082 int ecode3 = 0 ;
8083 int val4 ;
8084 int ecode4 = 0 ;
8085 int val5 ;
8086 int ecode5 = 0 ;
8087 PyObject * obj0 = 0 ;
8088 PyObject * obj1 = 0 ;
8089 PyObject * obj2 = 0 ;
8090 PyObject * obj3 = 0 ;
8091 PyObject * obj4 = 0 ;
8092 char * kwnames[] = {
8093 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8094 };
8095
8096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8098 if (!SWIG_IsOK(res1)) {
8099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8100 }
8101 arg1 = reinterpret_cast< wxRect * >(argp1);
8102 if (obj1) {
8103 ecode2 = SWIG_AsVal_int(obj1, &val2);
8104 if (!SWIG_IsOK(ecode2)) {
8105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8106 }
8107 arg2 = static_cast< int >(val2);
8108 }
8109 if (obj2) {
8110 ecode3 = SWIG_AsVal_int(obj2, &val3);
8111 if (!SWIG_IsOK(ecode3)) {
8112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8113 }
8114 arg3 = static_cast< int >(val3);
8115 }
8116 if (obj3) {
8117 ecode4 = SWIG_AsVal_int(obj3, &val4);
8118 if (!SWIG_IsOK(ecode4)) {
8119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8120 }
8121 arg4 = static_cast< int >(val4);
8122 }
8123 if (obj4) {
8124 ecode5 = SWIG_AsVal_int(obj4, &val5);
8125 if (!SWIG_IsOK(ecode5)) {
8126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8127 }
8128 arg5 = static_cast< int >(val5);
8129 }
8130 {
8131 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8132 if (PyErr_Occurred()) SWIG_fail;
8133 }
8134 resultobj = SWIG_Py_Void();
8135 return resultobj;
8136 fail:
8137 return NULL;
8138 }
8139
8140
8141 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8142 PyObject *resultobj = 0;
8143 wxRect *arg1 = (wxRect *) 0 ;
8144 PyObject *result = 0 ;
8145 void *argp1 = 0 ;
8146 int res1 = 0 ;
8147 PyObject *swig_obj[1] ;
8148
8149 if (!args) SWIG_fail;
8150 swig_obj[0] = args;
8151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8152 if (!SWIG_IsOK(res1)) {
8153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8154 }
8155 arg1 = reinterpret_cast< wxRect * >(argp1);
8156 {
8157 result = (PyObject *)wxRect_Get(arg1);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 resultobj = result;
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8168 PyObject *obj;
8169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8170 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8171 return SWIG_Py_Void();
8172 }
8173
8174 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8175 return SWIG_Python_InitShadowInstance(args);
8176 }
8177
8178 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj = 0;
8180 wxRect *arg1 = (wxRect *) 0 ;
8181 wxRect *arg2 = (wxRect *) 0 ;
8182 PyObject *result = 0 ;
8183 void *argp1 = 0 ;
8184 int res1 = 0 ;
8185 void *argp2 = 0 ;
8186 int res2 = 0 ;
8187 PyObject * obj0 = 0 ;
8188 PyObject * obj1 = 0 ;
8189 char * kwnames[] = {
8190 (char *) "r1",(char *) "r2", NULL
8191 };
8192
8193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8197 }
8198 arg1 = reinterpret_cast< wxRect * >(argp1);
8199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8200 if (!SWIG_IsOK(res2)) {
8201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8202 }
8203 arg2 = reinterpret_cast< wxRect * >(argp2);
8204 {
8205 if (!wxPyCheckForApp()) SWIG_fail;
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (PyObject *)wxIntersectRect(arg1,arg2);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 resultobj = result;
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8219 PyObject *resultobj = 0;
8220 double arg1 = (double) 0.0 ;
8221 double arg2 = (double) 0.0 ;
8222 wxPoint2D *result = 0 ;
8223 double val1 ;
8224 int ecode1 = 0 ;
8225 double val2 ;
8226 int ecode2 = 0 ;
8227 PyObject * obj0 = 0 ;
8228 PyObject * obj1 = 0 ;
8229 char * kwnames[] = {
8230 (char *) "x",(char *) "y", NULL
8231 };
8232
8233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8234 if (obj0) {
8235 ecode1 = SWIG_AsVal_double(obj0, &val1);
8236 if (!SWIG_IsOK(ecode1)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8238 }
8239 arg1 = static_cast< double >(val1);
8240 }
8241 if (obj1) {
8242 ecode2 = SWIG_AsVal_double(obj1, &val2);
8243 if (!SWIG_IsOK(ecode2)) {
8244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8245 }
8246 arg2 = static_cast< double >(val2);
8247 }
8248 {
8249 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8253 return resultobj;
8254 fail:
8255 return NULL;
8256 }
8257
8258
8259 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8260 PyObject *resultobj = 0;
8261 wxPoint2D *arg1 = 0 ;
8262 wxPoint2D *result = 0 ;
8263 wxPoint2D temp1 ;
8264 PyObject * obj0 = 0 ;
8265 char * kwnames[] = {
8266 (char *) "pt", NULL
8267 };
8268
8269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8270 {
8271 arg1 = &temp1;
8272 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8273 }
8274 {
8275 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj = 0;
8287 wxPoint *arg1 = 0 ;
8288 wxPoint2D *result = 0 ;
8289 wxPoint temp1 ;
8290 PyObject * obj0 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "pt", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8296 {
8297 arg1 = &temp1;
8298 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8299 }
8300 {
8301 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8312 PyObject *resultobj = 0;
8313 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 PyObject *swig_obj[1] ;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8323 }
8324 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8325 {
8326 delete arg1;
8327
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 resultobj = SWIG_Py_Void();
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8338 PyObject *resultobj = 0;
8339 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8340 int *arg2 = (int *) 0 ;
8341 int *arg3 = (int *) 0 ;
8342 void *argp1 = 0 ;
8343 int res1 = 0 ;
8344 int temp2 ;
8345 int res2 = SWIG_TMPOBJ ;
8346 int temp3 ;
8347 int res3 = SWIG_TMPOBJ ;
8348 PyObject *swig_obj[1] ;
8349
8350 arg2 = &temp2;
8351 arg3 = &temp3;
8352 if (!args) SWIG_fail;
8353 swig_obj[0] = args;
8354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8357 }
8358 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8359 {
8360 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8361 if (PyErr_Occurred()) SWIG_fail;
8362 }
8363 resultobj = SWIG_Py_Void();
8364 if (SWIG_IsTmpObj(res2)) {
8365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8366 } else {
8367 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8369 }
8370 if (SWIG_IsTmpObj(res3)) {
8371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8372 } else {
8373 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8375 }
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8383 PyObject *resultobj = 0;
8384 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8385 int *arg2 = (int *) 0 ;
8386 int *arg3 = (int *) 0 ;
8387 void *argp1 = 0 ;
8388 int res1 = 0 ;
8389 int temp2 ;
8390 int res2 = SWIG_TMPOBJ ;
8391 int temp3 ;
8392 int res3 = SWIG_TMPOBJ ;
8393 PyObject *swig_obj[1] ;
8394
8395 arg2 = &temp2;
8396 arg3 = &temp3;
8397 if (!args) SWIG_fail;
8398 swig_obj[0] = args;
8399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8400 if (!SWIG_IsOK(res1)) {
8401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8402 }
8403 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8404 {
8405 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 resultobj = SWIG_Py_Void();
8409 if (SWIG_IsTmpObj(res2)) {
8410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8411 } else {
8412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8414 }
8415 if (SWIG_IsTmpObj(res3)) {
8416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8417 } else {
8418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8420 }
8421 return resultobj;
8422 fail:
8423 return NULL;
8424 }
8425
8426
8427 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8428 PyObject *resultobj = 0;
8429 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8430 double result;
8431 void *argp1 = 0 ;
8432 int res1 = 0 ;
8433 PyObject *swig_obj[1] ;
8434
8435 if (!args) SWIG_fail;
8436 swig_obj[0] = args;
8437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8440 }
8441 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8442 {
8443 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_From_double(static_cast< double >(result));
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454 PyObject *resultobj = 0;
8455 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8456 double result;
8457 void *argp1 = 0 ;
8458 int res1 = 0 ;
8459 PyObject *swig_obj[1] ;
8460
8461 if (!args) SWIG_fail;
8462 swig_obj[0] = args;
8463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8466 }
8467 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8468 {
8469 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_From_double(static_cast< double >(result));
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj = 0;
8481 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8482 double arg2 ;
8483 void *argp1 = 0 ;
8484 int res1 = 0 ;
8485 double val2 ;
8486 int ecode2 = 0 ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char * kwnames[] = {
8490 (char *) "self",(char *) "length", NULL
8491 };
8492
8493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8495 if (!SWIG_IsOK(res1)) {
8496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8497 }
8498 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8499 ecode2 = SWIG_AsVal_double(obj1, &val2);
8500 if (!SWIG_IsOK(ecode2)) {
8501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8502 }
8503 arg2 = static_cast< double >(val2);
8504 {
8505 (arg1)->SetVectorLength(arg2);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_Py_Void();
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj = 0;
8517 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8518 double arg2 ;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 double val2 ;
8522 int ecode2 = 0 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 char * kwnames[] = {
8526 (char *) "self",(char *) "degrees", NULL
8527 };
8528
8529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8531 if (!SWIG_IsOK(res1)) {
8532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8533 }
8534 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8535 ecode2 = SWIG_AsVal_double(obj1, &val2);
8536 if (!SWIG_IsOK(ecode2)) {
8537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8538 }
8539 arg2 = static_cast< double >(val2);
8540 {
8541 (arg1)->SetVectorAngle(arg2);
8542 if (PyErr_Occurred()) SWIG_fail;
8543 }
8544 resultobj = SWIG_Py_Void();
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj = 0;
8553 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8554 wxPoint2D *arg2 = 0 ;
8555 double result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 wxPoint2D temp2 ;
8559 PyObject * obj0 = 0 ;
8560 PyObject * obj1 = 0 ;
8561 char * kwnames[] = {
8562 (char *) "self",(char *) "pt", NULL
8563 };
8564
8565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8567 if (!SWIG_IsOK(res1)) {
8568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8569 }
8570 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8571 {
8572 arg2 = &temp2;
8573 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8574 }
8575 {
8576 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8577 if (PyErr_Occurred()) SWIG_fail;
8578 }
8579 resultobj = SWIG_From_double(static_cast< double >(result));
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj = 0;
8588 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8589 wxPoint2D *arg2 = 0 ;
8590 double result;
8591 void *argp1 = 0 ;
8592 int res1 = 0 ;
8593 wxPoint2D temp2 ;
8594 PyObject * obj0 = 0 ;
8595 PyObject * obj1 = 0 ;
8596 char * kwnames[] = {
8597 (char *) "self",(char *) "pt", NULL
8598 };
8599
8600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8602 if (!SWIG_IsOK(res1)) {
8603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8604 }
8605 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8606 {
8607 arg2 = &temp2;
8608 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8609 }
8610 {
8611 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 resultobj = SWIG_From_double(static_cast< double >(result));
8615 return resultobj;
8616 fail:
8617 return NULL;
8618 }
8619
8620
8621 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj = 0;
8623 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8624 wxPoint2D *arg2 = 0 ;
8625 double result;
8626 void *argp1 = 0 ;
8627 int res1 = 0 ;
8628 wxPoint2D temp2 ;
8629 PyObject * obj0 = 0 ;
8630 PyObject * obj1 = 0 ;
8631 char * kwnames[] = {
8632 (char *) "self",(char *) "vec", NULL
8633 };
8634
8635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8637 if (!SWIG_IsOK(res1)) {
8638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8639 }
8640 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8641 {
8642 arg2 = &temp2;
8643 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8644 }
8645 {
8646 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8647 if (PyErr_Occurred()) SWIG_fail;
8648 }
8649 resultobj = SWIG_From_double(static_cast< double >(result));
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj = 0;
8658 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8659 wxPoint2D *arg2 = 0 ;
8660 double result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 wxPoint2D temp2 ;
8664 PyObject * obj0 = 0 ;
8665 PyObject * obj1 = 0 ;
8666 char * kwnames[] = {
8667 (char *) "self",(char *) "vec", NULL
8668 };
8669
8670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8672 if (!SWIG_IsOK(res1)) {
8673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8674 }
8675 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8676 {
8677 arg2 = &temp2;
8678 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8679 }
8680 {
8681 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 resultobj = SWIG_From_double(static_cast< double >(result));
8685 return resultobj;
8686 fail:
8687 return NULL;
8688 }
8689
8690
8691 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8692 PyObject *resultobj = 0;
8693 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8694 wxPoint2D result;
8695 void *argp1 = 0 ;
8696 int res1 = 0 ;
8697 PyObject *swig_obj[1] ;
8698
8699 if (!args) SWIG_fail;
8700 swig_obj[0] = args;
8701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 {
8707 result = (arg1)->operator -();
8708 if (PyErr_Occurred()) SWIG_fail;
8709 }
8710 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8711 return resultobj;
8712 fail:
8713 return NULL;
8714 }
8715
8716
8717 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8718 PyObject *resultobj = 0;
8719 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8720 wxPoint2D *arg2 = 0 ;
8721 wxPoint2D *result = 0 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 wxPoint2D temp2 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "pt", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8735 }
8736 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8737 {
8738 arg2 = &temp2;
8739 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8740 }
8741 {
8742 {
8743 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8744 result = (wxPoint2D *) &_result_ref;
8745 }
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8758 wxPoint2D *arg2 = 0 ;
8759 wxPoint2D *result = 0 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 wxPoint2D temp2 ;
8763 PyObject * obj0 = 0 ;
8764 PyObject * obj1 = 0 ;
8765 char * kwnames[] = {
8766 (char *) "self",(char *) "pt", NULL
8767 };
8768
8769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8771 if (!SWIG_IsOK(res1)) {
8772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8773 }
8774 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8775 {
8776 arg2 = &temp2;
8777 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8778 }
8779 {
8780 {
8781 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8782 result = (wxPoint2D *) &_result_ref;
8783 }
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8796 wxPoint2D *arg2 = 0 ;
8797 wxPoint2D *result = 0 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 wxPoint2D temp2 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "pt", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 arg2 = &temp2;
8815 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8816 }
8817 {
8818 {
8819 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8820 result = (wxPoint2D *) &_result_ref;
8821 }
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 wxPoint2D *arg2 = 0 ;
8835 wxPoint2D *result = 0 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 wxPoint2D temp2 ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 char * kwnames[] = {
8842 (char *) "self",(char *) "pt", NULL
8843 };
8844
8845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8847 if (!SWIG_IsOK(res1)) {
8848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8849 }
8850 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8851 {
8852 arg2 = &temp2;
8853 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8854 }
8855 {
8856 {
8857 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8858 result = (wxPoint2D *) &_result_ref;
8859 }
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj = 0;
8871 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8872 PyObject *arg2 = (PyObject *) 0 ;
8873 bool result;
8874 void *argp1 = 0 ;
8875 int res1 = 0 ;
8876 PyObject * obj0 = 0 ;
8877 PyObject * obj1 = 0 ;
8878 char * kwnames[] = {
8879 (char *) "self",(char *) "other", NULL
8880 };
8881
8882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8884 if (!SWIG_IsOK(res1)) {
8885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8886 }
8887 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8888 arg2 = obj1;
8889 {
8890 result = (bool)wxPoint2D___eq__(arg1,arg2);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 {
8894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8895 }
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj = 0;
8904 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8905 PyObject *arg2 = (PyObject *) 0 ;
8906 bool result;
8907 void *argp1 = 0 ;
8908 int res1 = 0 ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 char * kwnames[] = {
8912 (char *) "self",(char *) "other", NULL
8913 };
8914
8915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8917 if (!SWIG_IsOK(res1)) {
8918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8919 }
8920 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8921 arg2 = obj1;
8922 {
8923 result = (bool)wxPoint2D___ne__(arg1,arg2);
8924 if (PyErr_Occurred()) SWIG_fail;
8925 }
8926 {
8927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8928 }
8929 return resultobj;
8930 fail:
8931 return NULL;
8932 }
8933
8934
8935 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8936 PyObject *resultobj = 0;
8937 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8938 double arg2 ;
8939 void *argp1 = 0 ;
8940 int res1 = 0 ;
8941 double val2 ;
8942 int ecode2 = 0 ;
8943 PyObject *swig_obj[2] ;
8944
8945 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8947 if (!SWIG_IsOK(res1)) {
8948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8949 }
8950 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8951 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8952 if (!SWIG_IsOK(ecode2)) {
8953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8954 }
8955 arg2 = static_cast< double >(val2);
8956 if (arg1) (arg1)->m_x = arg2;
8957
8958 resultobj = SWIG_Py_Void();
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8966 PyObject *resultobj = 0;
8967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8968 double result;
8969 void *argp1 = 0 ;
8970 int res1 = 0 ;
8971 PyObject *swig_obj[1] ;
8972
8973 if (!args) SWIG_fail;
8974 swig_obj[0] = args;
8975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8978 }
8979 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8980 result = (double) ((arg1)->m_x);
8981 resultobj = SWIG_From_double(static_cast< double >(result));
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8989 PyObject *resultobj = 0;
8990 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8991 double arg2 ;
8992 void *argp1 = 0 ;
8993 int res1 = 0 ;
8994 double val2 ;
8995 int ecode2 = 0 ;
8996 PyObject *swig_obj[2] ;
8997
8998 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9004 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9005 if (!SWIG_IsOK(ecode2)) {
9006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9007 }
9008 arg2 = static_cast< double >(val2);
9009 if (arg1) (arg1)->m_y = arg2;
9010
9011 resultobj = SWIG_Py_Void();
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 double result;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 PyObject *swig_obj[1] ;
9025
9026 if (!args) SWIG_fail;
9027 swig_obj[0] = args;
9028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9029 if (!SWIG_IsOK(res1)) {
9030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9031 }
9032 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9033 result = (double) ((arg1)->m_y);
9034 resultobj = SWIG_From_double(static_cast< double >(result));
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9044 double arg2 = (double) 0 ;
9045 double arg3 = (double) 0 ;
9046 void *argp1 = 0 ;
9047 int res1 = 0 ;
9048 double val2 ;
9049 int ecode2 = 0 ;
9050 double val3 ;
9051 int ecode3 = 0 ;
9052 PyObject * obj0 = 0 ;
9053 PyObject * obj1 = 0 ;
9054 PyObject * obj2 = 0 ;
9055 char * kwnames[] = {
9056 (char *) "self",(char *) "x",(char *) "y", NULL
9057 };
9058
9059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9061 if (!SWIG_IsOK(res1)) {
9062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9063 }
9064 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9065 if (obj1) {
9066 ecode2 = SWIG_AsVal_double(obj1, &val2);
9067 if (!SWIG_IsOK(ecode2)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9069 }
9070 arg2 = static_cast< double >(val2);
9071 }
9072 if (obj2) {
9073 ecode3 = SWIG_AsVal_double(obj2, &val3);
9074 if (!SWIG_IsOK(ecode3)) {
9075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9076 }
9077 arg3 = static_cast< double >(val3);
9078 }
9079 {
9080 wxPoint2D_Set(arg1,arg2,arg3);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = SWIG_Py_Void();
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9091 PyObject *resultobj = 0;
9092 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9093 PyObject *result = 0 ;
9094 void *argp1 = 0 ;
9095 int res1 = 0 ;
9096 PyObject *swig_obj[1] ;
9097
9098 if (!args) SWIG_fail;
9099 swig_obj[0] = args;
9100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9105 {
9106 result = (PyObject *)wxPoint2D_Get(arg1);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 resultobj = result;
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9117 PyObject *obj;
9118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9119 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9120 return SWIG_Py_Void();
9121 }
9122
9123 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9124 return SWIG_Python_InitShadowInstance(args);
9125 }
9126
9127 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj = 0;
9129 wxDouble arg1 = (wxDouble) 0.0 ;
9130 wxDouble arg2 = (wxDouble) 0.0 ;
9131 wxDouble arg3 = (wxDouble) 0.0 ;
9132 wxDouble arg4 = (wxDouble) 0.0 ;
9133 wxRect2D *result = 0 ;
9134 void *argp1 ;
9135 int res1 = 0 ;
9136 void *argp2 ;
9137 int res2 = 0 ;
9138 void *argp3 ;
9139 int res3 = 0 ;
9140 void *argp4 ;
9141 int res4 = 0 ;
9142 PyObject * obj0 = 0 ;
9143 PyObject * obj1 = 0 ;
9144 PyObject * obj2 = 0 ;
9145 PyObject * obj3 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9151 if (obj0) {
9152 {
9153 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9154 if (!SWIG_IsOK(res1)) {
9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9156 }
9157 if (!argp1) {
9158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9159 } else {
9160 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9161 arg1 = *temp;
9162 if (SWIG_IsNewObj(res1)) delete temp;
9163 }
9164 }
9165 }
9166 if (obj1) {
9167 {
9168 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9169 if (!SWIG_IsOK(res2)) {
9170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9171 }
9172 if (!argp2) {
9173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9174 } else {
9175 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9176 arg2 = *temp;
9177 if (SWIG_IsNewObj(res2)) delete temp;
9178 }
9179 }
9180 }
9181 if (obj2) {
9182 {
9183 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9184 if (!SWIG_IsOK(res3)) {
9185 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9186 }
9187 if (!argp3) {
9188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9189 } else {
9190 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9191 arg3 = *temp;
9192 if (SWIG_IsNewObj(res3)) delete temp;
9193 }
9194 }
9195 }
9196 if (obj3) {
9197 {
9198 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9199 if (!SWIG_IsOK(res4)) {
9200 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9201 }
9202 if (!argp4) {
9203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9204 } else {
9205 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9206 arg4 = *temp;
9207 if (SWIG_IsNewObj(res4)) delete temp;
9208 }
9209 }
9210 }
9211 {
9212 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9216 return resultobj;
9217 fail:
9218 return NULL;
9219 }
9220
9221
9222 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9223 PyObject *resultobj = 0;
9224 wxRect2D *arg1 = (wxRect2D *) 0 ;
9225 void *argp1 = 0 ;
9226 int res1 = 0 ;
9227 PyObject *swig_obj[1] ;
9228
9229 if (!args) SWIG_fail;
9230 swig_obj[0] = args;
9231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9232 if (!SWIG_IsOK(res1)) {
9233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9234 }
9235 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9236 {
9237 delete arg1;
9238
9239 if (PyErr_Occurred()) SWIG_fail;
9240 }
9241 resultobj = SWIG_Py_Void();
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
9248 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9249 PyObject *resultobj = 0;
9250 wxRect2D *arg1 = (wxRect2D *) 0 ;
9251 wxPoint2D result;
9252 void *argp1 = 0 ;
9253 int res1 = 0 ;
9254 PyObject *swig_obj[1] ;
9255
9256 if (!args) SWIG_fail;
9257 swig_obj[0] = args;
9258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9261 }
9262 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9263 {
9264 result = (arg1)->GetPosition();
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *resultobj = 0;
9276 wxRect2D *arg1 = (wxRect2D *) 0 ;
9277 wxSize result;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9287 }
9288 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9289 {
9290 result = (arg1)->GetSize();
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxRect2D *arg1 = (wxRect2D *) 0 ;
9303 wxDouble result;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 PyObject *swig_obj[1] ;
9307
9308 if (!args) SWIG_fail;
9309 swig_obj[0] = args;
9310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9313 }
9314 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9315 {
9316 result = ((wxRect2D const *)arg1)->GetLeft();
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9320 return resultobj;
9321 fail:
9322 return NULL;
9323 }
9324
9325
9326 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9327 PyObject *resultobj = 0;
9328 wxRect2D *arg1 = (wxRect2D *) 0 ;
9329 wxDouble arg2 ;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 void *argp2 ;
9333 int res2 = 0 ;
9334 PyObject * obj0 = 0 ;
9335 PyObject * obj1 = 0 ;
9336 char * kwnames[] = {
9337 (char *) "self",(char *) "n", NULL
9338 };
9339
9340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9344 }
9345 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9346 {
9347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9348 if (!SWIG_IsOK(res2)) {
9349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9350 }
9351 if (!argp2) {
9352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9353 } else {
9354 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9355 arg2 = *temp;
9356 if (SWIG_IsNewObj(res2)) delete temp;
9357 }
9358 }
9359 {
9360 (arg1)->SetLeft(arg2);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_Py_Void();
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9371 PyObject *resultobj = 0;
9372 wxRect2D *arg1 = (wxRect2D *) 0 ;
9373 wxDouble arg2 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 void *argp2 ;
9377 int res2 = 0 ;
9378 PyObject * obj0 = 0 ;
9379 PyObject * obj1 = 0 ;
9380 char * kwnames[] = {
9381 (char *) "self",(char *) "n", NULL
9382 };
9383
9384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9388 }
9389 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9390 {
9391 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9392 if (!SWIG_IsOK(res2)) {
9393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9394 }
9395 if (!argp2) {
9396 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9397 } else {
9398 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9399 arg2 = *temp;
9400 if (SWIG_IsNewObj(res2)) delete temp;
9401 }
9402 }
9403 {
9404 (arg1)->MoveLeftTo(arg2);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 resultobj = SWIG_Py_Void();
9408 return resultobj;
9409 fail:
9410 return NULL;
9411 }
9412
9413
9414 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9415 PyObject *resultobj = 0;
9416 wxRect2D *arg1 = (wxRect2D *) 0 ;
9417 wxDouble result;
9418 void *argp1 = 0 ;
9419 int res1 = 0 ;
9420 PyObject *swig_obj[1] ;
9421
9422 if (!args) SWIG_fail;
9423 swig_obj[0] = args;
9424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9427 }
9428 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9429 {
9430 result = ((wxRect2D const *)arg1)->GetTop();
9431 if (PyErr_Occurred()) SWIG_fail;
9432 }
9433 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9434 return resultobj;
9435 fail:
9436 return NULL;
9437 }
9438
9439
9440 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj = 0;
9442 wxRect2D *arg1 = (wxRect2D *) 0 ;
9443 wxDouble arg2 ;
9444 void *argp1 = 0 ;
9445 int res1 = 0 ;
9446 void *argp2 ;
9447 int res2 = 0 ;
9448 PyObject * obj0 = 0 ;
9449 PyObject * obj1 = 0 ;
9450 char * kwnames[] = {
9451 (char *) "self",(char *) "n", NULL
9452 };
9453
9454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9456 if (!SWIG_IsOK(res1)) {
9457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9458 }
9459 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9460 {
9461 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9462 if (!SWIG_IsOK(res2)) {
9463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9464 }
9465 if (!argp2) {
9466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9467 } else {
9468 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9469 arg2 = *temp;
9470 if (SWIG_IsNewObj(res2)) delete temp;
9471 }
9472 }
9473 {
9474 (arg1)->SetTop(arg2);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_Py_Void();
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxRect2D *arg1 = (wxRect2D *) 0 ;
9487 wxDouble arg2 ;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 void *argp2 ;
9491 int res2 = 0 ;
9492 PyObject * obj0 = 0 ;
9493 PyObject * obj1 = 0 ;
9494 char * kwnames[] = {
9495 (char *) "self",(char *) "n", NULL
9496 };
9497
9498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9502 }
9503 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9504 {
9505 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9506 if (!SWIG_IsOK(res2)) {
9507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9508 }
9509 if (!argp2) {
9510 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9511 } else {
9512 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9513 arg2 = *temp;
9514 if (SWIG_IsNewObj(res2)) delete temp;
9515 }
9516 }
9517 {
9518 (arg1)->MoveTopTo(arg2);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_Py_Void();
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9529 PyObject *resultobj = 0;
9530 wxRect2D *arg1 = (wxRect2D *) 0 ;
9531 wxDouble result;
9532 void *argp1 = 0 ;
9533 int res1 = 0 ;
9534 PyObject *swig_obj[1] ;
9535
9536 if (!args) SWIG_fail;
9537 swig_obj[0] = args;
9538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9541 }
9542 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9543 {
9544 result = ((wxRect2D const *)arg1)->GetBottom();
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9548 return resultobj;
9549 fail:
9550 return NULL;
9551 }
9552
9553
9554 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9555 PyObject *resultobj = 0;
9556 wxRect2D *arg1 = (wxRect2D *) 0 ;
9557 wxDouble arg2 ;
9558 void *argp1 = 0 ;
9559 int res1 = 0 ;
9560 void *argp2 ;
9561 int res2 = 0 ;
9562 PyObject * obj0 = 0 ;
9563 PyObject * obj1 = 0 ;
9564 char * kwnames[] = {
9565 (char *) "self",(char *) "n", NULL
9566 };
9567
9568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9572 }
9573 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9574 {
9575 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9576 if (!SWIG_IsOK(res2)) {
9577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9578 }
9579 if (!argp2) {
9580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9581 } else {
9582 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9583 arg2 = *temp;
9584 if (SWIG_IsNewObj(res2)) delete temp;
9585 }
9586 }
9587 {
9588 (arg1)->SetBottom(arg2);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_Py_Void();
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj = 0;
9600 wxRect2D *arg1 = (wxRect2D *) 0 ;
9601 wxDouble arg2 ;
9602 void *argp1 = 0 ;
9603 int res1 = 0 ;
9604 void *argp2 ;
9605 int res2 = 0 ;
9606 PyObject * obj0 = 0 ;
9607 PyObject * obj1 = 0 ;
9608 char * kwnames[] = {
9609 (char *) "self",(char *) "n", NULL
9610 };
9611
9612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9614 if (!SWIG_IsOK(res1)) {
9615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9616 }
9617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9618 {
9619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9620 if (!SWIG_IsOK(res2)) {
9621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9622 }
9623 if (!argp2) {
9624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9625 } else {
9626 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9627 arg2 = *temp;
9628 if (SWIG_IsNewObj(res2)) delete temp;
9629 }
9630 }
9631 {
9632 (arg1)->MoveBottomTo(arg2);
9633 if (PyErr_Occurred()) SWIG_fail;
9634 }
9635 resultobj = SWIG_Py_Void();
9636 return resultobj;
9637 fail:
9638 return NULL;
9639 }
9640
9641
9642 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9643 PyObject *resultobj = 0;
9644 wxRect2D *arg1 = (wxRect2D *) 0 ;
9645 wxDouble result;
9646 void *argp1 = 0 ;
9647 int res1 = 0 ;
9648 PyObject *swig_obj[1] ;
9649
9650 if (!args) SWIG_fail;
9651 swig_obj[0] = args;
9652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9653 if (!SWIG_IsOK(res1)) {
9654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9655 }
9656 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9657 {
9658 result = ((wxRect2D const *)arg1)->GetRight();
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9669 PyObject *resultobj = 0;
9670 wxRect2D *arg1 = (wxRect2D *) 0 ;
9671 wxDouble arg2 ;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 void *argp2 ;
9675 int res2 = 0 ;
9676 PyObject * obj0 = 0 ;
9677 PyObject * obj1 = 0 ;
9678 char * kwnames[] = {
9679 (char *) "self",(char *) "n", NULL
9680 };
9681
9682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9684 if (!SWIG_IsOK(res1)) {
9685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9686 }
9687 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9688 {
9689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9690 if (!SWIG_IsOK(res2)) {
9691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9692 }
9693 if (!argp2) {
9694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9695 } else {
9696 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9697 arg2 = *temp;
9698 if (SWIG_IsNewObj(res2)) delete temp;
9699 }
9700 }
9701 {
9702 (arg1)->SetRight(arg2);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_Py_Void();
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj = 0;
9714 wxRect2D *arg1 = (wxRect2D *) 0 ;
9715 wxDouble arg2 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 void *argp2 ;
9719 int res2 = 0 ;
9720 PyObject * obj0 = 0 ;
9721 PyObject * obj1 = 0 ;
9722 char * kwnames[] = {
9723 (char *) "self",(char *) "n", NULL
9724 };
9725
9726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9730 }
9731 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9732 {
9733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9734 if (!SWIG_IsOK(res2)) {
9735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9736 }
9737 if (!argp2) {
9738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9739 } else {
9740 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9741 arg2 = *temp;
9742 if (SWIG_IsNewObj(res2)) delete temp;
9743 }
9744 }
9745 {
9746 (arg1)->MoveRightTo(arg2);
9747 if (PyErr_Occurred()) SWIG_fail;
9748 }
9749 resultobj = SWIG_Py_Void();
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 PyObject *resultobj = 0;
9758 wxRect2D *arg1 = (wxRect2D *) 0 ;
9759 wxPoint2D result;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 PyObject *swig_obj[1] ;
9763
9764 if (!args) SWIG_fail;
9765 swig_obj[0] = args;
9766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9769 }
9770 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9771 {
9772 result = ((wxRect2D const *)arg1)->GetLeftTop();
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9776 return resultobj;
9777 fail:
9778 return NULL;
9779 }
9780
9781
9782 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9783 PyObject *resultobj = 0;
9784 wxRect2D *arg1 = (wxRect2D *) 0 ;
9785 wxPoint2D *arg2 = 0 ;
9786 void *argp1 = 0 ;
9787 int res1 = 0 ;
9788 wxPoint2D temp2 ;
9789 PyObject * obj0 = 0 ;
9790 PyObject * obj1 = 0 ;
9791 char * kwnames[] = {
9792 (char *) "self",(char *) "pt", NULL
9793 };
9794
9795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9799 }
9800 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9801 {
9802 arg2 = &temp2;
9803 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9804 }
9805 {
9806 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_Py_Void();
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj = 0;
9818 wxRect2D *arg1 = (wxRect2D *) 0 ;
9819 wxPoint2D *arg2 = 0 ;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 wxPoint2D temp2 ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 char * kwnames[] = {
9826 (char *) "self",(char *) "pt", NULL
9827 };
9828
9829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9831 if (!SWIG_IsOK(res1)) {
9832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9833 }
9834 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9835 {
9836 arg2 = &temp2;
9837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9838 }
9839 {
9840 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_Py_Void();
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9851 PyObject *resultobj = 0;
9852 wxRect2D *arg1 = (wxRect2D *) 0 ;
9853 wxPoint2D result;
9854 void *argp1 = 0 ;
9855 int res1 = 0 ;
9856 PyObject *swig_obj[1] ;
9857
9858 if (!args) SWIG_fail;
9859 swig_obj[0] = args;
9860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9861 if (!SWIG_IsOK(res1)) {
9862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9863 }
9864 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9865 {
9866 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxRect2D *arg1 = (wxRect2D *) 0 ;
9879 wxPoint2D *arg2 = 0 ;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 wxPoint2D temp2 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char * kwnames[] = {
9886 (char *) "self",(char *) "pt", NULL
9887 };
9888
9889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9893 }
9894 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9895 {
9896 arg2 = &temp2;
9897 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9898 }
9899 {
9900 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
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 *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj = 0;
9912 wxRect2D *arg1 = (wxRect2D *) 0 ;
9913 wxPoint2D *arg2 = 0 ;
9914 void *argp1 = 0 ;
9915 int res1 = 0 ;
9916 wxPoint2D temp2 ;
9917 PyObject * obj0 = 0 ;
9918 PyObject * obj1 = 0 ;
9919 char * kwnames[] = {
9920 (char *) "self",(char *) "pt", NULL
9921 };
9922
9923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9925 if (!SWIG_IsOK(res1)) {
9926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9927 }
9928 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9929 {
9930 arg2 = &temp2;
9931 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9932 }
9933 {
9934 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 resultobj = SWIG_Py_Void();
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9945 PyObject *resultobj = 0;
9946 wxRect2D *arg1 = (wxRect2D *) 0 ;
9947 wxPoint2D result;
9948 void *argp1 = 0 ;
9949 int res1 = 0 ;
9950 PyObject *swig_obj[1] ;
9951
9952 if (!args) SWIG_fail;
9953 swig_obj[0] = args;
9954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9955 if (!SWIG_IsOK(res1)) {
9956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9957 }
9958 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9959 {
9960 result = ((wxRect2D const *)arg1)->GetRightTop();
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = 0;
9972 wxRect2D *arg1 = (wxRect2D *) 0 ;
9973 wxPoint2D *arg2 = 0 ;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 wxPoint2D temp2 ;
9977 PyObject * obj0 = 0 ;
9978 PyObject * obj1 = 0 ;
9979 char * kwnames[] = {
9980 (char *) "self",(char *) "pt", NULL
9981 };
9982
9983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9985 if (!SWIG_IsOK(res1)) {
9986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9987 }
9988 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9989 {
9990 arg2 = &temp2;
9991 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9992 }
9993 {
9994 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj = 0;
10006 wxRect2D *arg1 = (wxRect2D *) 0 ;
10007 wxPoint2D *arg2 = 0 ;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 wxPoint2D temp2 ;
10011 PyObject * obj0 = 0 ;
10012 PyObject * obj1 = 0 ;
10013 char * kwnames[] = {
10014 (char *) "self",(char *) "pt", NULL
10015 };
10016
10017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10021 }
10022 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10023 {
10024 arg2 = &temp2;
10025 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10026 }
10027 {
10028 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 resultobj = SWIG_Py_Void();
10032 return resultobj;
10033 fail:
10034 return NULL;
10035 }
10036
10037
10038 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 PyObject *resultobj = 0;
10040 wxRect2D *arg1 = (wxRect2D *) 0 ;
10041 wxPoint2D result;
10042 void *argp1 = 0 ;
10043 int res1 = 0 ;
10044 PyObject *swig_obj[1] ;
10045
10046 if (!args) SWIG_fail;
10047 swig_obj[0] = args;
10048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10049 if (!SWIG_IsOK(res1)) {
10050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10051 }
10052 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10053 {
10054 result = ((wxRect2D const *)arg1)->GetRightBottom();
10055 if (PyErr_Occurred()) SWIG_fail;
10056 }
10057 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj = 0;
10066 wxRect2D *arg1 = (wxRect2D *) 0 ;
10067 wxPoint2D *arg2 = 0 ;
10068 void *argp1 = 0 ;
10069 int res1 = 0 ;
10070 wxPoint2D temp2 ;
10071 PyObject * obj0 = 0 ;
10072 PyObject * obj1 = 0 ;
10073 char * kwnames[] = {
10074 (char *) "self",(char *) "pt", NULL
10075 };
10076
10077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10081 }
10082 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10083 {
10084 arg2 = &temp2;
10085 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10086 }
10087 {
10088 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_Py_Void();
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj = 0;
10100 wxRect2D *arg1 = (wxRect2D *) 0 ;
10101 wxPoint2D *arg2 = 0 ;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 wxPoint2D temp2 ;
10105 PyObject * obj0 = 0 ;
10106 PyObject * obj1 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "pt", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10115 }
10116 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10117 {
10118 arg2 = &temp2;
10119 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10120 }
10121 {
10122 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 resultobj = SWIG_Py_Void();
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 PyObject *resultobj = 0;
10134 wxRect2D *arg1 = (wxRect2D *) 0 ;
10135 wxPoint2D result;
10136 void *argp1 = 0 ;
10137 int res1 = 0 ;
10138 PyObject *swig_obj[1] ;
10139
10140 if (!args) SWIG_fail;
10141 swig_obj[0] = args;
10142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10143 if (!SWIG_IsOK(res1)) {
10144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10145 }
10146 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10147 {
10148 result = ((wxRect2D const *)arg1)->GetCentre();
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj = 0;
10160 wxRect2D *arg1 = (wxRect2D *) 0 ;
10161 wxPoint2D *arg2 = 0 ;
10162 void *argp1 = 0 ;
10163 int res1 = 0 ;
10164 wxPoint2D temp2 ;
10165 PyObject * obj0 = 0 ;
10166 PyObject * obj1 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "pt", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10175 }
10176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10177 {
10178 arg2 = &temp2;
10179 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10180 }
10181 {
10182 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 resultobj = SWIG_Py_Void();
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10193 PyObject *resultobj = 0;
10194 wxRect2D *arg1 = (wxRect2D *) 0 ;
10195 wxPoint2D *arg2 = 0 ;
10196 void *argp1 = 0 ;
10197 int res1 = 0 ;
10198 wxPoint2D temp2 ;
10199 PyObject * obj0 = 0 ;
10200 PyObject * obj1 = 0 ;
10201 char * kwnames[] = {
10202 (char *) "self",(char *) "pt", NULL
10203 };
10204
10205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10207 if (!SWIG_IsOK(res1)) {
10208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10209 }
10210 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10211 {
10212 arg2 = &temp2;
10213 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10214 }
10215 {
10216 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 resultobj = SWIG_Py_Void();
10220 return resultobj;
10221 fail:
10222 return NULL;
10223 }
10224
10225
10226 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj = 0;
10228 wxRect2D *arg1 = (wxRect2D *) 0 ;
10229 wxPoint2D *arg2 = 0 ;
10230 wxOutCode result;
10231 void *argp1 = 0 ;
10232 int res1 = 0 ;
10233 wxPoint2D temp2 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 char * kwnames[] = {
10237 (char *) "self",(char *) "pt", NULL
10238 };
10239
10240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10244 }
10245 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10246 {
10247 arg2 = &temp2;
10248 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10249 }
10250 {
10251 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10252 if (PyErr_Occurred()) SWIG_fail;
10253 }
10254 resultobj = SWIG_From_int(static_cast< int >(result));
10255 return resultobj;
10256 fail:
10257 return NULL;
10258 }
10259
10260
10261 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10262 PyObject *resultobj = 0;
10263 wxRect2D *arg1 = (wxRect2D *) 0 ;
10264 wxPoint2D *arg2 = 0 ;
10265 bool result;
10266 void *argp1 = 0 ;
10267 int res1 = 0 ;
10268 wxPoint2D temp2 ;
10269 PyObject * obj0 = 0 ;
10270 PyObject * obj1 = 0 ;
10271 char * kwnames[] = {
10272 (char *) "self",(char *) "pt", NULL
10273 };
10274
10275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10277 if (!SWIG_IsOK(res1)) {
10278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10279 }
10280 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10281 {
10282 arg2 = &temp2;
10283 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10284 }
10285 {
10286 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 {
10290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10291 }
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj = 0;
10300 wxRect2D *arg1 = (wxRect2D *) 0 ;
10301 wxRect2D *arg2 = 0 ;
10302 bool result;
10303 void *argp1 = 0 ;
10304 int res1 = 0 ;
10305 wxRect2D temp2 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 char * kwnames[] = {
10309 (char *) "self",(char *) "rect", NULL
10310 };
10311
10312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10314 if (!SWIG_IsOK(res1)) {
10315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10316 }
10317 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10318 {
10319 arg2 = &temp2;
10320 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10321 }
10322 {
10323 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10324 if (PyErr_Occurred()) SWIG_fail;
10325 }
10326 {
10327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10328 }
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10336 PyObject *resultobj = 0;
10337 wxRect2D *arg1 = (wxRect2D *) 0 ;
10338 bool result;
10339 void *argp1 = 0 ;
10340 int res1 = 0 ;
10341 PyObject *swig_obj[1] ;
10342
10343 if (!args) SWIG_fail;
10344 swig_obj[0] = args;
10345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10346 if (!SWIG_IsOK(res1)) {
10347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10348 }
10349 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10350 {
10351 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10352 if (PyErr_Occurred()) SWIG_fail;
10353 }
10354 {
10355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10356 }
10357 return resultobj;
10358 fail:
10359 return NULL;
10360 }
10361
10362
10363 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10364 PyObject *resultobj = 0;
10365 wxRect2D *arg1 = (wxRect2D *) 0 ;
10366 wxRect2D *arg2 = 0 ;
10367 bool result;
10368 void *argp1 = 0 ;
10369 int res1 = 0 ;
10370 wxRect2D temp2 ;
10371 PyObject * obj0 = 0 ;
10372 PyObject * obj1 = 0 ;
10373 char * kwnames[] = {
10374 (char *) "self",(char *) "rect", NULL
10375 };
10376
10377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10379 if (!SWIG_IsOK(res1)) {
10380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10381 }
10382 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10383 {
10384 arg2 = &temp2;
10385 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10386 }
10387 {
10388 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10389 if (PyErr_Occurred()) SWIG_fail;
10390 }
10391 {
10392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10393 }
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10401 PyObject *resultobj = 0;
10402 wxRect2D *arg1 = (wxRect2D *) 0 ;
10403 wxDouble arg2 ;
10404 wxDouble arg3 ;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 void *argp2 ;
10408 int res2 = 0 ;
10409 void *argp3 ;
10410 int res3 = 0 ;
10411
10412 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10414 if (!SWIG_IsOK(res1)) {
10415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10416 }
10417 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10418 {
10419 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10420 if (!SWIG_IsOK(res2)) {
10421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10422 }
10423 if (!argp2) {
10424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10425 } else {
10426 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10427 arg2 = *temp;
10428 if (SWIG_IsNewObj(res2)) delete temp;
10429 }
10430 }
10431 {
10432 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10433 if (!SWIG_IsOK(res3)) {
10434 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10435 }
10436 if (!argp3) {
10437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10438 } else {
10439 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10440 arg3 = *temp;
10441 if (SWIG_IsNewObj(res3)) delete temp;
10442 }
10443 }
10444 {
10445 (arg1)->Inset(arg2,arg3);
10446 if (PyErr_Occurred()) SWIG_fail;
10447 }
10448 resultobj = SWIG_Py_Void();
10449 return resultobj;
10450 fail:
10451 return NULL;
10452 }
10453
10454
10455 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10456 PyObject *resultobj = 0;
10457 wxRect2D *arg1 = (wxRect2D *) 0 ;
10458 wxDouble arg2 ;
10459 wxDouble arg3 ;
10460 wxDouble arg4 ;
10461 wxDouble arg5 ;
10462 void *argp1 = 0 ;
10463 int res1 = 0 ;
10464 void *argp2 ;
10465 int res2 = 0 ;
10466 void *argp3 ;
10467 int res3 = 0 ;
10468 void *argp4 ;
10469 int res4 = 0 ;
10470 void *argp5 ;
10471 int res5 = 0 ;
10472
10473 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10475 if (!SWIG_IsOK(res1)) {
10476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10477 }
10478 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10479 {
10480 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10481 if (!SWIG_IsOK(res2)) {
10482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10483 }
10484 if (!argp2) {
10485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10486 } else {
10487 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10488 arg2 = *temp;
10489 if (SWIG_IsNewObj(res2)) delete temp;
10490 }
10491 }
10492 {
10493 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10494 if (!SWIG_IsOK(res3)) {
10495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10496 }
10497 if (!argp3) {
10498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10499 } else {
10500 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10501 arg3 = *temp;
10502 if (SWIG_IsNewObj(res3)) delete temp;
10503 }
10504 }
10505 {
10506 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10507 if (!SWIG_IsOK(res4)) {
10508 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10509 }
10510 if (!argp4) {
10511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10512 } else {
10513 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10514 arg4 = *temp;
10515 if (SWIG_IsNewObj(res4)) delete temp;
10516 }
10517 }
10518 {
10519 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10520 if (!SWIG_IsOK(res5)) {
10521 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10522 }
10523 if (!argp5) {
10524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10525 } else {
10526 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10527 arg5 = *temp;
10528 if (SWIG_IsNewObj(res5)) delete temp;
10529 }
10530 }
10531 {
10532 (arg1)->Inset(arg2,arg3,arg4,arg5);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 resultobj = SWIG_Py_Void();
10536 return resultobj;
10537 fail:
10538 return NULL;
10539 }
10540
10541
10542 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10543 int argc;
10544 PyObject *argv[6];
10545
10546 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10547 --argc;
10548 if (argc == 3) {
10549 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10550 }
10551 if (argc == 5) {
10552 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10553 }
10554
10555 fail:
10556 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj = 0;
10563 wxRect2D *arg1 = (wxRect2D *) 0 ;
10564 wxPoint2D *arg2 = 0 ;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 wxPoint2D temp2 ;
10568 PyObject * obj0 = 0 ;
10569 PyObject * obj1 = 0 ;
10570 char * kwnames[] = {
10571 (char *) "self",(char *) "pt", NULL
10572 };
10573
10574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10576 if (!SWIG_IsOK(res1)) {
10577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10578 }
10579 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10580 {
10581 arg2 = &temp2;
10582 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10583 }
10584 {
10585 (arg1)->Offset((wxPoint2D const &)*arg2);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 resultobj = SWIG_Py_Void();
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = 0;
10597 wxRect2D *arg1 = (wxRect2D *) 0 ;
10598 wxRect2D *arg2 = 0 ;
10599 void *argp1 = 0 ;
10600 int res1 = 0 ;
10601 wxRect2D temp2 ;
10602 PyObject * obj0 = 0 ;
10603 PyObject * obj1 = 0 ;
10604 char * kwnames[] = {
10605 (char *) "self",(char *) "rect", NULL
10606 };
10607
10608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10610 if (!SWIG_IsOK(res1)) {
10611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10612 }
10613 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10614 {
10615 arg2 = &temp2;
10616 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10617 }
10618 {
10619 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 resultobj = SWIG_Py_Void();
10623 return resultobj;
10624 fail:
10625 return NULL;
10626 }
10627
10628
10629 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10630 PyObject *resultobj = 0;
10631 wxRect2D *arg1 = (wxRect2D *) 0 ;
10632 int arg2 ;
10633 int arg3 ;
10634 wxPoint2D result;
10635 void *argp1 = 0 ;
10636 int res1 = 0 ;
10637 int val2 ;
10638 int ecode2 = 0 ;
10639 int val3 ;
10640 int ecode3 = 0 ;
10641 PyObject * obj0 = 0 ;
10642 PyObject * obj1 = 0 ;
10643 PyObject * obj2 = 0 ;
10644 char * kwnames[] = {
10645 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10646 };
10647
10648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10650 if (!SWIG_IsOK(res1)) {
10651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10652 }
10653 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10654 ecode2 = SWIG_AsVal_int(obj1, &val2);
10655 if (!SWIG_IsOK(ecode2)) {
10656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10657 }
10658 arg2 = static_cast< int >(val2);
10659 ecode3 = SWIG_AsVal_int(obj2, &val3);
10660 if (!SWIG_IsOK(ecode3)) {
10661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10662 }
10663 arg3 = static_cast< int >(val3);
10664 {
10665 result = (arg1)->Interpolate(arg2,arg3);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxRect2D *arg1 = (wxRect2D *) 0 ;
10678 wxRect2D *arg2 = 0 ;
10679 void *argp1 = 0 ;
10680 int res1 = 0 ;
10681 wxRect2D temp2 ;
10682 PyObject * obj0 = 0 ;
10683 PyObject * obj1 = 0 ;
10684 char * kwnames[] = {
10685 (char *) "self",(char *) "otherRect", NULL
10686 };
10687
10688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10690 if (!SWIG_IsOK(res1)) {
10691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10692 }
10693 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10694 {
10695 arg2 = &temp2;
10696 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10697 }
10698 {
10699 (arg1)->Intersect((wxRect2D const &)*arg2);
10700 if (PyErr_Occurred()) SWIG_fail;
10701 }
10702 resultobj = SWIG_Py_Void();
10703 return resultobj;
10704 fail:
10705 return NULL;
10706 }
10707
10708
10709 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10710 PyObject *resultobj = 0;
10711 wxRect2D *arg1 = (wxRect2D *) 0 ;
10712 wxRect2D *arg2 = 0 ;
10713 wxRect2D result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 wxRect2D temp2 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 char * kwnames[] = {
10720 (char *) "self",(char *) "otherRect", NULL
10721 };
10722
10723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10727 }
10728 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10729 {
10730 arg2 = &temp2;
10731 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10732 }
10733 {
10734 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10735 if (PyErr_Occurred()) SWIG_fail;
10736 }
10737 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxRect2D *arg1 = (wxRect2D *) 0 ;
10747 wxRect2D *arg2 = 0 ;
10748 bool result;
10749 void *argp1 = 0 ;
10750 int res1 = 0 ;
10751 wxRect2D temp2 ;
10752 PyObject * obj0 = 0 ;
10753 PyObject * obj1 = 0 ;
10754 char * kwnames[] = {
10755 (char *) "self",(char *) "rect", NULL
10756 };
10757
10758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10760 if (!SWIG_IsOK(res1)) {
10761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10762 }
10763 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10764 {
10765 arg2 = &temp2;
10766 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10767 }
10768 {
10769 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 {
10773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10774 }
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10782 PyObject *resultobj = 0;
10783 wxRect2D *arg1 = (wxRect2D *) 0 ;
10784 wxRect2D *arg2 = 0 ;
10785 void *argp1 = 0 ;
10786 int res1 = 0 ;
10787 wxRect2D temp2 ;
10788 PyObject * obj0 = 0 ;
10789 PyObject * obj1 = 0 ;
10790 char * kwnames[] = {
10791 (char *) "self",(char *) "otherRect", NULL
10792 };
10793
10794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10798 }
10799 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10800 {
10801 arg2 = &temp2;
10802 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10803 }
10804 {
10805 (arg1)->Union((wxRect2D const &)*arg2);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_Py_Void();
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10816 PyObject *resultobj = 0;
10817 wxRect2D *arg1 = (wxRect2D *) 0 ;
10818 wxRect2D *arg2 = 0 ;
10819 wxRect2D result;
10820 void *argp1 = 0 ;
10821 int res1 = 0 ;
10822 wxRect2D temp2 ;
10823 PyObject * obj0 = 0 ;
10824 PyObject * obj1 = 0 ;
10825 char * kwnames[] = {
10826 (char *) "self",(char *) "otherRect", NULL
10827 };
10828
10829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10831 if (!SWIG_IsOK(res1)) {
10832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10833 }
10834 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10835 {
10836 arg2 = &temp2;
10837 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10838 }
10839 {
10840 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10844 return resultobj;
10845 fail:
10846 return NULL;
10847 }
10848
10849
10850 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10851 PyObject *resultobj = 0;
10852 wxRect2D *arg1 = (wxRect2D *) 0 ;
10853 wxDouble arg2 ;
10854 void *argp1 = 0 ;
10855 int res1 = 0 ;
10856 void *argp2 ;
10857 int res2 = 0 ;
10858
10859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10861 if (!SWIG_IsOK(res1)) {
10862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10863 }
10864 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10865 {
10866 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10867 if (!SWIG_IsOK(res2)) {
10868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10869 }
10870 if (!argp2) {
10871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10872 } else {
10873 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10874 arg2 = *temp;
10875 if (SWIG_IsNewObj(res2)) delete temp;
10876 }
10877 }
10878 {
10879 (arg1)->Scale(arg2);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10890 PyObject *resultobj = 0;
10891 wxRect2D *arg1 = (wxRect2D *) 0 ;
10892 int arg2 ;
10893 int arg3 ;
10894 void *argp1 = 0 ;
10895 int res1 = 0 ;
10896 int val2 ;
10897 int ecode2 = 0 ;
10898 int val3 ;
10899 int ecode3 = 0 ;
10900
10901 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10903 if (!SWIG_IsOK(res1)) {
10904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10905 }
10906 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10907 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10908 if (!SWIG_IsOK(ecode2)) {
10909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10910 }
10911 arg2 = static_cast< int >(val2);
10912 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10913 if (!SWIG_IsOK(ecode3)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10915 }
10916 arg3 = static_cast< int >(val3);
10917 {
10918 (arg1)->Scale(arg2,arg3);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 resultobj = SWIG_Py_Void();
10922 return resultobj;
10923 fail:
10924 return NULL;
10925 }
10926
10927
10928 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10929 int argc;
10930 PyObject *argv[4];
10931
10932 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10933 --argc;
10934 if (argc == 2) {
10935 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10936 }
10937 if (argc == 3) {
10938 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10939 }
10940
10941 fail:
10942 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxRect2D *arg1 = (wxRect2D *) 0 ;
10950 PyObject *arg2 = (PyObject *) 0 ;
10951 bool result;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 char * kwnames[] = {
10957 (char *) "self",(char *) "other", NULL
10958 };
10959
10960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10962 if (!SWIG_IsOK(res1)) {
10963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10964 }
10965 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10966 arg2 = obj1;
10967 {
10968 result = (bool)wxRect2D___eq__(arg1,arg2);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 {
10972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10973 }
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = 0;
10982 wxRect2D *arg1 = (wxRect2D *) 0 ;
10983 PyObject *arg2 = (PyObject *) 0 ;
10984 bool result;
10985 void *argp1 = 0 ;
10986 int res1 = 0 ;
10987 PyObject * obj0 = 0 ;
10988 PyObject * obj1 = 0 ;
10989 char * kwnames[] = {
10990 (char *) "self",(char *) "other", NULL
10991 };
10992
10993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10995 if (!SWIG_IsOK(res1)) {
10996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10997 }
10998 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10999 arg2 = obj1;
11000 {
11001 result = (bool)wxRect2D___ne__(arg1,arg2);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 {
11005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11006 }
11007 return resultobj;
11008 fail:
11009 return NULL;
11010 }
11011
11012
11013 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11014 PyObject *resultobj = 0;
11015 wxRect2D *arg1 = (wxRect2D *) 0 ;
11016 wxDouble arg2 ;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 void *argp2 ;
11020 int res2 = 0 ;
11021 PyObject *swig_obj[2] ;
11022
11023 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11025 if (!SWIG_IsOK(res1)) {
11026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11027 }
11028 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11029 {
11030 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11031 if (!SWIG_IsOK(res2)) {
11032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11033 }
11034 if (!argp2) {
11035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11036 } else {
11037 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11038 arg2 = *temp;
11039 if (SWIG_IsNewObj(res2)) delete temp;
11040 }
11041 }
11042 if (arg1) (arg1)->m_x = arg2;
11043
11044 resultobj = SWIG_Py_Void();
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11052 PyObject *resultobj = 0;
11053 wxRect2D *arg1 = (wxRect2D *) 0 ;
11054 wxDouble result;
11055 void *argp1 = 0 ;
11056 int res1 = 0 ;
11057 PyObject *swig_obj[1] ;
11058
11059 if (!args) SWIG_fail;
11060 swig_obj[0] = args;
11061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11062 if (!SWIG_IsOK(res1)) {
11063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11064 }
11065 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11066 result = ((arg1)->m_x);
11067 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11075 PyObject *resultobj = 0;
11076 wxRect2D *arg1 = (wxRect2D *) 0 ;
11077 wxDouble arg2 ;
11078 void *argp1 = 0 ;
11079 int res1 = 0 ;
11080 void *argp2 ;
11081 int res2 = 0 ;
11082 PyObject *swig_obj[2] ;
11083
11084 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11086 if (!SWIG_IsOK(res1)) {
11087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11088 }
11089 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11090 {
11091 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11092 if (!SWIG_IsOK(res2)) {
11093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11094 }
11095 if (!argp2) {
11096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11097 } else {
11098 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11099 arg2 = *temp;
11100 if (SWIG_IsNewObj(res2)) delete temp;
11101 }
11102 }
11103 if (arg1) (arg1)->m_y = arg2;
11104
11105 resultobj = SWIG_Py_Void();
11106 return resultobj;
11107 fail:
11108 return NULL;
11109 }
11110
11111
11112 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113 PyObject *resultobj = 0;
11114 wxRect2D *arg1 = (wxRect2D *) 0 ;
11115 wxDouble result;
11116 void *argp1 = 0 ;
11117 int res1 = 0 ;
11118 PyObject *swig_obj[1] ;
11119
11120 if (!args) SWIG_fail;
11121 swig_obj[0] = args;
11122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11125 }
11126 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11127 result = ((arg1)->m_y);
11128 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11136 PyObject *resultobj = 0;
11137 wxRect2D *arg1 = (wxRect2D *) 0 ;
11138 wxDouble arg2 ;
11139 void *argp1 = 0 ;
11140 int res1 = 0 ;
11141 void *argp2 ;
11142 int res2 = 0 ;
11143 PyObject *swig_obj[2] ;
11144
11145 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11147 if (!SWIG_IsOK(res1)) {
11148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11149 }
11150 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11151 {
11152 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11153 if (!SWIG_IsOK(res2)) {
11154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11155 }
11156 if (!argp2) {
11157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11158 } else {
11159 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11160 arg2 = *temp;
11161 if (SWIG_IsNewObj(res2)) delete temp;
11162 }
11163 }
11164 if (arg1) (arg1)->m_width = arg2;
11165
11166 resultobj = SWIG_Py_Void();
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11174 PyObject *resultobj = 0;
11175 wxRect2D *arg1 = (wxRect2D *) 0 ;
11176 wxDouble result;
11177 void *argp1 = 0 ;
11178 int res1 = 0 ;
11179 PyObject *swig_obj[1] ;
11180
11181 if (!args) SWIG_fail;
11182 swig_obj[0] = args;
11183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11184 if (!SWIG_IsOK(res1)) {
11185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11186 }
11187 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11188 result = ((arg1)->m_width);
11189 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198 wxRect2D *arg1 = (wxRect2D *) 0 ;
11199 wxDouble arg2 ;
11200 void *argp1 = 0 ;
11201 int res1 = 0 ;
11202 void *argp2 ;
11203 int res2 = 0 ;
11204 PyObject *swig_obj[2] ;
11205
11206 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11210 }
11211 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11212 {
11213 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11214 if (!SWIG_IsOK(res2)) {
11215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11216 }
11217 if (!argp2) {
11218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11219 } else {
11220 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11221 arg2 = *temp;
11222 if (SWIG_IsNewObj(res2)) delete temp;
11223 }
11224 }
11225 if (arg1) (arg1)->m_height = arg2;
11226
11227 resultobj = SWIG_Py_Void();
11228 return resultobj;
11229 fail:
11230 return NULL;
11231 }
11232
11233
11234 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11235 PyObject *resultobj = 0;
11236 wxRect2D *arg1 = (wxRect2D *) 0 ;
11237 wxDouble result;
11238 void *argp1 = 0 ;
11239 int res1 = 0 ;
11240 PyObject *swig_obj[1] ;
11241
11242 if (!args) SWIG_fail;
11243 swig_obj[0] = args;
11244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11247 }
11248 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11249 result = ((arg1)->m_height);
11250 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11251 return resultobj;
11252 fail:
11253 return NULL;
11254 }
11255
11256
11257 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj = 0;
11259 wxRect2D *arg1 = (wxRect2D *) 0 ;
11260 wxDouble arg2 = (wxDouble) 0 ;
11261 wxDouble arg3 = (wxDouble) 0 ;
11262 wxDouble arg4 = (wxDouble) 0 ;
11263 wxDouble arg5 = (wxDouble) 0 ;
11264 void *argp1 = 0 ;
11265 int res1 = 0 ;
11266 void *argp2 ;
11267 int res2 = 0 ;
11268 void *argp3 ;
11269 int res3 = 0 ;
11270 void *argp4 ;
11271 int res4 = 0 ;
11272 void *argp5 ;
11273 int res5 = 0 ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 PyObject * obj3 = 0 ;
11278 PyObject * obj4 = 0 ;
11279 char * kwnames[] = {
11280 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11281 };
11282
11283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11285 if (!SWIG_IsOK(res1)) {
11286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11287 }
11288 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11289 if (obj1) {
11290 {
11291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11292 if (!SWIG_IsOK(res2)) {
11293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11294 }
11295 if (!argp2) {
11296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11297 } else {
11298 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11299 arg2 = *temp;
11300 if (SWIG_IsNewObj(res2)) delete temp;
11301 }
11302 }
11303 }
11304 if (obj2) {
11305 {
11306 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11307 if (!SWIG_IsOK(res3)) {
11308 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11309 }
11310 if (!argp3) {
11311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11312 } else {
11313 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11314 arg3 = *temp;
11315 if (SWIG_IsNewObj(res3)) delete temp;
11316 }
11317 }
11318 }
11319 if (obj3) {
11320 {
11321 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11322 if (!SWIG_IsOK(res4)) {
11323 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11324 }
11325 if (!argp4) {
11326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11327 } else {
11328 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11329 arg4 = *temp;
11330 if (SWIG_IsNewObj(res4)) delete temp;
11331 }
11332 }
11333 }
11334 if (obj4) {
11335 {
11336 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11337 if (!SWIG_IsOK(res5)) {
11338 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11339 }
11340 if (!argp5) {
11341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11342 } else {
11343 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11344 arg5 = *temp;
11345 if (SWIG_IsNewObj(res5)) delete temp;
11346 }
11347 }
11348 }
11349 {
11350 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 resultobj = SWIG_Py_Void();
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11361 PyObject *resultobj = 0;
11362 wxRect2D *arg1 = (wxRect2D *) 0 ;
11363 PyObject *result = 0 ;
11364 void *argp1 = 0 ;
11365 int res1 = 0 ;
11366 PyObject *swig_obj[1] ;
11367
11368 if (!args) SWIG_fail;
11369 swig_obj[0] = args;
11370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11371 if (!SWIG_IsOK(res1)) {
11372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11373 }
11374 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11375 {
11376 result = (PyObject *)wxRect2D_Get(arg1);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = result;
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *obj;
11388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11389 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11390 return SWIG_Py_Void();
11391 }
11392
11393 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11394 return SWIG_Python_InitShadowInstance(args);
11395 }
11396
11397 SWIGINTERN int DefaultPosition_set(PyObject *) {
11398 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11399 return 1;
11400 }
11401
11402
11403 SWIGINTERN PyObject *DefaultPosition_get(void) {
11404 PyObject *pyobj = 0;
11405
11406 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11407 return pyobj;
11408 }
11409
11410
11411 SWIGINTERN int DefaultSize_set(PyObject *) {
11412 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11413 return 1;
11414 }
11415
11416
11417 SWIGINTERN PyObject *DefaultSize_get(void) {
11418 PyObject *pyobj = 0;
11419
11420 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11421 return pyobj;
11422 }
11423
11424
11425 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj = 0;
11427 PyObject *arg1 = (PyObject *) 0 ;
11428 wxPyInputStream *result = 0 ;
11429 PyObject * obj0 = 0 ;
11430 char * kwnames[] = {
11431 (char *) "p", NULL
11432 };
11433
11434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11435 arg1 = obj0;
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11450 PyObject *resultobj = 0;
11451 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11452 void *argp1 = 0 ;
11453 int res1 = 0 ;
11454 PyObject *swig_obj[1] ;
11455
11456 if (!args) SWIG_fail;
11457 swig_obj[0] = args;
11458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11459 if (!SWIG_IsOK(res1)) {
11460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11461 }
11462 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11463 {
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 delete arg1;
11466
11467 wxPyEndAllowThreads(__tstate);
11468 if (PyErr_Occurred()) SWIG_fail;
11469 }
11470 resultobj = SWIG_Py_Void();
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11478 PyObject *resultobj = 0;
11479 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11480 void *argp1 = 0 ;
11481 int res1 = 0 ;
11482 PyObject *swig_obj[1] ;
11483
11484 if (!args) SWIG_fail;
11485 swig_obj[0] = args;
11486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11487 if (!SWIG_IsOK(res1)) {
11488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11489 }
11490 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 (arg1)->close();
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 resultobj = SWIG_Py_Void();
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11505 PyObject *resultobj = 0;
11506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11507 void *argp1 = 0 ;
11508 int res1 = 0 ;
11509 PyObject *swig_obj[1] ;
11510
11511 if (!args) SWIG_fail;
11512 swig_obj[0] = args;
11513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11514 if (!SWIG_IsOK(res1)) {
11515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11516 }
11517 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11518 {
11519 PyThreadState* __tstate = wxPyBeginAllowThreads();
11520 (arg1)->flush();
11521 wxPyEndAllowThreads(__tstate);
11522 if (PyErr_Occurred()) SWIG_fail;
11523 }
11524 resultobj = SWIG_Py_Void();
11525 return resultobj;
11526 fail:
11527 return NULL;
11528 }
11529
11530
11531 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11532 PyObject *resultobj = 0;
11533 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11534 bool result;
11535 void *argp1 = 0 ;
11536 int res1 = 0 ;
11537 PyObject *swig_obj[1] ;
11538
11539 if (!args) SWIG_fail;
11540 swig_obj[0] = args;
11541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11542 if (!SWIG_IsOK(res1)) {
11543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11544 }
11545 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 result = (bool)(arg1)->eof();
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj = 0;
11563 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11564 int arg2 = (int) -1 ;
11565 PyObject *result = 0 ;
11566 void *argp1 = 0 ;
11567 int res1 = 0 ;
11568 int val2 ;
11569 int ecode2 = 0 ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 char * kwnames[] = {
11573 (char *) "self",(char *) "size", NULL
11574 };
11575
11576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11578 if (!SWIG_IsOK(res1)) {
11579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11580 }
11581 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11582 if (obj1) {
11583 ecode2 = SWIG_AsVal_int(obj1, &val2);
11584 if (!SWIG_IsOK(ecode2)) {
11585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11586 }
11587 arg2 = static_cast< int >(val2);
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (PyObject *)(arg1)->read(arg2);
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = result;
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = 0;
11604 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11605 int arg2 = (int) -1 ;
11606 PyObject *result = 0 ;
11607 void *argp1 = 0 ;
11608 int res1 = 0 ;
11609 int val2 ;
11610 int ecode2 = 0 ;
11611 PyObject * obj0 = 0 ;
11612 PyObject * obj1 = 0 ;
11613 char * kwnames[] = {
11614 (char *) "self",(char *) "size", NULL
11615 };
11616
11617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11619 if (!SWIG_IsOK(res1)) {
11620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11621 }
11622 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11623 if (obj1) {
11624 ecode2 = SWIG_AsVal_int(obj1, &val2);
11625 if (!SWIG_IsOK(ecode2)) {
11626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11627 }
11628 arg2 = static_cast< int >(val2);
11629 }
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 result = (PyObject *)(arg1)->readline(arg2);
11633 wxPyEndAllowThreads(__tstate);
11634 if (PyErr_Occurred()) SWIG_fail;
11635 }
11636 resultobj = result;
11637 return resultobj;
11638 fail:
11639 return NULL;
11640 }
11641
11642
11643 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11644 PyObject *resultobj = 0;
11645 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11646 int arg2 = (int) -1 ;
11647 PyObject *result = 0 ;
11648 void *argp1 = 0 ;
11649 int res1 = 0 ;
11650 int val2 ;
11651 int ecode2 = 0 ;
11652 PyObject * obj0 = 0 ;
11653 PyObject * obj1 = 0 ;
11654 char * kwnames[] = {
11655 (char *) "self",(char *) "sizehint", NULL
11656 };
11657
11658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11660 if (!SWIG_IsOK(res1)) {
11661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11662 }
11663 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11664 if (obj1) {
11665 ecode2 = SWIG_AsVal_int(obj1, &val2);
11666 if (!SWIG_IsOK(ecode2)) {
11667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11668 }
11669 arg2 = static_cast< int >(val2);
11670 }
11671 {
11672 PyThreadState* __tstate = wxPyBeginAllowThreads();
11673 result = (PyObject *)(arg1)->readlines(arg2);
11674 wxPyEndAllowThreads(__tstate);
11675 if (PyErr_Occurred()) SWIG_fail;
11676 }
11677 resultobj = result;
11678 return resultobj;
11679 fail:
11680 return NULL;
11681 }
11682
11683
11684 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11685 PyObject *resultobj = 0;
11686 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11687 int arg2 ;
11688 int arg3 = (int) 0 ;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 int val2 ;
11692 int ecode2 = 0 ;
11693 int val3 ;
11694 int ecode3 = 0 ;
11695 PyObject * obj0 = 0 ;
11696 PyObject * obj1 = 0 ;
11697 PyObject * obj2 = 0 ;
11698 char * kwnames[] = {
11699 (char *) "self",(char *) "offset",(char *) "whence", NULL
11700 };
11701
11702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11706 }
11707 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11708 ecode2 = SWIG_AsVal_int(obj1, &val2);
11709 if (!SWIG_IsOK(ecode2)) {
11710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11711 }
11712 arg2 = static_cast< int >(val2);
11713 if (obj2) {
11714 ecode3 = SWIG_AsVal_int(obj2, &val3);
11715 if (!SWIG_IsOK(ecode3)) {
11716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11717 }
11718 arg3 = static_cast< int >(val3);
11719 }
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 (arg1)->seek(arg2,arg3);
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 resultobj = SWIG_Py_Void();
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11736 int result;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (int)(arg1)->tell();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_From_int(static_cast< int >(result));
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11764 char result;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 PyObject *swig_obj[1] ;
11768
11769 if (!args) SWIG_fail;
11770 swig_obj[0] = args;
11771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11774 }
11775 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (char)(arg1)->Peek();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 resultobj = SWIG_From_char(static_cast< char >(result));
11783 return resultobj;
11784 fail:
11785 return NULL;
11786 }
11787
11788
11789 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11790 PyObject *resultobj = 0;
11791 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11792 char result;
11793 void *argp1 = 0 ;
11794 int res1 = 0 ;
11795 PyObject *swig_obj[1] ;
11796
11797 if (!args) SWIG_fail;
11798 swig_obj[0] = args;
11799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11800 if (!SWIG_IsOK(res1)) {
11801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11802 }
11803 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 result = (char)(arg1)->GetC();
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 resultobj = SWIG_From_char(static_cast< char >(result));
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11818 PyObject *resultobj = 0;
11819 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11820 size_t result;
11821 void *argp1 = 0 ;
11822 int res1 = 0 ;
11823 PyObject *swig_obj[1] ;
11824
11825 if (!args) SWIG_fail;
11826 swig_obj[0] = args;
11827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11828 if (!SWIG_IsOK(res1)) {
11829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11830 }
11831 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11832 {
11833 PyThreadState* __tstate = wxPyBeginAllowThreads();
11834 result = (size_t)(arg1)->LastRead();
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11839 return resultobj;
11840 fail:
11841 return NULL;
11842 }
11843
11844
11845 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11846 PyObject *resultobj = 0;
11847 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11848 bool result;
11849 void *argp1 = 0 ;
11850 int res1 = 0 ;
11851 PyObject *swig_obj[1] ;
11852
11853 if (!args) SWIG_fail;
11854 swig_obj[0] = args;
11855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11856 if (!SWIG_IsOK(res1)) {
11857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11858 }
11859 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 result = (bool)(arg1)->CanRead();
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11868 }
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11876 PyObject *resultobj = 0;
11877 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11878 bool result;
11879 void *argp1 = 0 ;
11880 int res1 = 0 ;
11881 PyObject *swig_obj[1] ;
11882
11883 if (!args) SWIG_fail;
11884 swig_obj[0] = args;
11885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11886 if (!SWIG_IsOK(res1)) {
11887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11888 }
11889 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (bool)(arg1)->Eof();
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 {
11897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11898 }
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj = 0;
11907 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11908 char arg2 ;
11909 bool result;
11910 void *argp1 = 0 ;
11911 int res1 = 0 ;
11912 char val2 ;
11913 int ecode2 = 0 ;
11914 PyObject * obj0 = 0 ;
11915 PyObject * obj1 = 0 ;
11916 char * kwnames[] = {
11917 (char *) "self",(char *) "c", NULL
11918 };
11919
11920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11922 if (!SWIG_IsOK(res1)) {
11923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11924 }
11925 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11926 ecode2 = SWIG_AsVal_char(obj1, &val2);
11927 if (!SWIG_IsOK(ecode2)) {
11928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11929 }
11930 arg2 = static_cast< char >(val2);
11931 {
11932 PyThreadState* __tstate = wxPyBeginAllowThreads();
11933 result = (bool)(arg1)->Ungetch(arg2);
11934 wxPyEndAllowThreads(__tstate);
11935 if (PyErr_Occurred()) SWIG_fail;
11936 }
11937 {
11938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11939 }
11940 return resultobj;
11941 fail:
11942 return NULL;
11943 }
11944
11945
11946 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11947 PyObject *resultobj = 0;
11948 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11949 long arg2 ;
11950 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11951 long result;
11952 void *argp1 = 0 ;
11953 int res1 = 0 ;
11954 long val2 ;
11955 int ecode2 = 0 ;
11956 int val3 ;
11957 int ecode3 = 0 ;
11958 PyObject * obj0 = 0 ;
11959 PyObject * obj1 = 0 ;
11960 PyObject * obj2 = 0 ;
11961 char * kwnames[] = {
11962 (char *) "self",(char *) "pos",(char *) "mode", NULL
11963 };
11964
11965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11967 if (!SWIG_IsOK(res1)) {
11968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11969 }
11970 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11971 ecode2 = SWIG_AsVal_long(obj1, &val2);
11972 if (!SWIG_IsOK(ecode2)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11974 }
11975 arg2 = static_cast< long >(val2);
11976 if (obj2) {
11977 ecode3 = SWIG_AsVal_int(obj2, &val3);
11978 if (!SWIG_IsOK(ecode3)) {
11979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11980 }
11981 arg3 = static_cast< wxSeekMode >(val3);
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (long)(arg1)->SeekI(arg2,arg3);
11986 wxPyEndAllowThreads(__tstate);
11987 if (PyErr_Occurred()) SWIG_fail;
11988 }
11989 resultobj = SWIG_From_long(static_cast< long >(result));
11990 return resultobj;
11991 fail:
11992 return NULL;
11993 }
11994
11995
11996 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11997 PyObject *resultobj = 0;
11998 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11999 long result;
12000 void *argp1 = 0 ;
12001 int res1 = 0 ;
12002 PyObject *swig_obj[1] ;
12003
12004 if (!args) SWIG_fail;
12005 swig_obj[0] = args;
12006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12007 if (!SWIG_IsOK(res1)) {
12008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12009 }
12010 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (long)(arg1)->TellI();
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 resultobj = SWIG_From_long(static_cast< long >(result));
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12025 PyObject *obj;
12026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12027 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12028 return SWIG_Py_Void();
12029 }
12030
12031 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 return SWIG_Python_InitShadowInstance(args);
12033 }
12034
12035 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12036 PyObject *resultobj = 0;
12037 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12038 PyObject *arg2 = (PyObject *) 0 ;
12039 void *argp1 = 0 ;
12040 int res1 = 0 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "self",(char *) "obj", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12051 }
12052 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12053 arg2 = obj1;
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 wxOutputStream_write(arg1,arg2);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_Py_Void();
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12068 PyObject *resultobj = 0;
12069 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12070 size_t result;
12071 void *argp1 = 0 ;
12072 int res1 = 0 ;
12073 PyObject *swig_obj[1] ;
12074
12075 if (!args) SWIG_fail;
12076 swig_obj[0] = args;
12077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12080 }
12081 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *obj;
12097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12098 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12099 return SWIG_Py_Void();
12100 }
12101
12102 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj = 0;
12104 wxInputStream *arg1 = (wxInputStream *) 0 ;
12105 wxString *arg2 = 0 ;
12106 wxString *arg3 = 0 ;
12107 wxString *arg4 = 0 ;
12108 wxDateTime arg5 ;
12109 wxFSFile *result = 0 ;
12110 wxPyInputStream *temp1 ;
12111 bool temp2 = false ;
12112 bool temp3 = false ;
12113 bool temp4 = false ;
12114 void *argp5 ;
12115 int res5 = 0 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 PyObject * obj2 = 0 ;
12119 PyObject * obj3 = 0 ;
12120 PyObject * obj4 = 0 ;
12121 char * kwnames[] = {
12122 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12123 };
12124
12125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12126 {
12127 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12128 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12129 } else {
12130 PyErr_Clear(); // clear the failure of the wxPyConvert above
12131 arg1 = wxPyCBInputStream_create(obj0, true);
12132 if (arg1 == NULL) {
12133 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12134 SWIG_fail;
12135 }
12136 }
12137 }
12138 {
12139 arg2 = wxString_in_helper(obj1);
12140 if (arg2 == NULL) SWIG_fail;
12141 temp2 = true;
12142 }
12143 {
12144 arg3 = wxString_in_helper(obj2);
12145 if (arg3 == NULL) SWIG_fail;
12146 temp3 = true;
12147 }
12148 {
12149 arg4 = wxString_in_helper(obj3);
12150 if (arg4 == NULL) SWIG_fail;
12151 temp4 = true;
12152 }
12153 {
12154 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12155 if (!SWIG_IsOK(res5)) {
12156 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12157 }
12158 if (!argp5) {
12159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12160 } else {
12161 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12162 arg5 = *temp;
12163 if (SWIG_IsNewObj(res5)) delete temp;
12164 }
12165 }
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12173 {
12174 if (temp2)
12175 delete arg2;
12176 }
12177 {
12178 if (temp3)
12179 delete arg3;
12180 }
12181 {
12182 if (temp4)
12183 delete arg4;
12184 }
12185 return resultobj;
12186 fail:
12187 {
12188 if (temp2)
12189 delete arg2;
12190 }
12191 {
12192 if (temp3)
12193 delete arg3;
12194 }
12195 {
12196 if (temp4)
12197 delete arg4;
12198 }
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *resultobj = 0;
12205 wxFSFile *arg1 = (wxFSFile *) 0 ;
12206 void *argp1 = 0 ;
12207 int res1 = 0 ;
12208 PyObject *swig_obj[1] ;
12209
12210 if (!args) SWIG_fail;
12211 swig_obj[0] = args;
12212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12213 if (!SWIG_IsOK(res1)) {
12214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12215 }
12216 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 delete arg1;
12220
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_Py_Void();
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12232 PyObject *resultobj = 0;
12233 wxFSFile *arg1 = (wxFSFile *) 0 ;
12234 wxInputStream *result = 0 ;
12235 void *argp1 = 0 ;
12236 int res1 = 0 ;
12237 PyObject *swig_obj[1] ;
12238
12239 if (!args) SWIG_fail;
12240 swig_obj[0] = args;
12241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12244 }
12245 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12246 {
12247 PyThreadState* __tstate = wxPyBeginAllowThreads();
12248 result = (wxInputStream *)(arg1)->GetStream();
12249 wxPyEndAllowThreads(__tstate);
12250 if (PyErr_Occurred()) SWIG_fail;
12251 }
12252 {
12253 wxPyInputStream * _ptr = NULL;
12254
12255 if (result) {
12256 _ptr = new wxPyInputStream(result);
12257 }
12258 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12259 }
12260 return resultobj;
12261 fail:
12262 return NULL;
12263 }
12264
12265
12266 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12267 PyObject *resultobj = 0;
12268 wxFSFile *arg1 = (wxFSFile *) 0 ;
12269 void *argp1 = 0 ;
12270 int res1 = 0 ;
12271 PyObject *swig_obj[1] ;
12272
12273 if (!args) SWIG_fail;
12274 swig_obj[0] = args;
12275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12276 if (!SWIG_IsOK(res1)) {
12277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12278 }
12279 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12280 {
12281 PyThreadState* __tstate = wxPyBeginAllowThreads();
12282 (arg1)->DetachStream();
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 resultobj = SWIG_Py_Void();
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12294 PyObject *resultobj = 0;
12295 wxFSFile *arg1 = (wxFSFile *) 0 ;
12296 wxString *result = 0 ;
12297 void *argp1 = 0 ;
12298 int res1 = 0 ;
12299 PyObject *swig_obj[1] ;
12300
12301 if (!args) SWIG_fail;
12302 swig_obj[0] = args;
12303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12304 if (!SWIG_IsOK(res1)) {
12305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12306 }
12307 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 {
12311 wxString const &_result_ref = (arg1)->GetMimeType();
12312 result = (wxString *) &_result_ref;
12313 }
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 {
12318 #if wxUSE_UNICODE
12319 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12320 #else
12321 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12322 #endif
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332 wxFSFile *arg1 = (wxFSFile *) 0 ;
12333 wxString *result = 0 ;
12334 void *argp1 = 0 ;
12335 int res1 = 0 ;
12336 PyObject *swig_obj[1] ;
12337
12338 if (!args) SWIG_fail;
12339 swig_obj[0] = args;
12340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12341 if (!SWIG_IsOK(res1)) {
12342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12343 }
12344 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 {
12348 wxString const &_result_ref = (arg1)->GetLocation();
12349 result = (wxString *) &_result_ref;
12350 }
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 {
12355 #if wxUSE_UNICODE
12356 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12357 #else
12358 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12359 #endif
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 PyObject *resultobj = 0;
12369 wxFSFile *arg1 = (wxFSFile *) 0 ;
12370 wxString *result = 0 ;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 PyObject *swig_obj[1] ;
12374
12375 if (!args) SWIG_fail;
12376 swig_obj[0] = args;
12377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12378 if (!SWIG_IsOK(res1)) {
12379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12380 }
12381 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 {
12385 wxString const &_result_ref = (arg1)->GetAnchor();
12386 result = (wxString *) &_result_ref;
12387 }
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 #if wxUSE_UNICODE
12393 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12394 #else
12395 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12396 #endif
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12405 PyObject *resultobj = 0;
12406 wxFSFile *arg1 = (wxFSFile *) 0 ;
12407 wxDateTime result;
12408 void *argp1 = 0 ;
12409 int res1 = 0 ;
12410 PyObject *swig_obj[1] ;
12411
12412 if (!args) SWIG_fail;
12413 swig_obj[0] = args;
12414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12415 if (!SWIG_IsOK(res1)) {
12416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12417 }
12418 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 result = (arg1)->GetModificationTime();
12422 wxPyEndAllowThreads(__tstate);
12423 if (PyErr_Occurred()) SWIG_fail;
12424 }
12425 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433 PyObject *obj;
12434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12435 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12436 return SWIG_Py_Void();
12437 }
12438
12439 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12440 return SWIG_Python_InitShadowInstance(args);
12441 }
12442
12443 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 PyObject *resultobj = 0;
12445 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 PyObject *swig_obj[1] ;
12449
12450 if (!args) SWIG_fail;
12451 swig_obj[0] = args;
12452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12455 }
12456 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 delete arg1;
12460
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_Py_Void();
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12472 PyObject *obj;
12473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12474 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12475 return SWIG_Py_Void();
12476 }
12477
12478 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12479 PyObject *resultobj = 0;
12480 wxPyFileSystemHandler *result = 0 ;
12481
12482 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12483 {
12484 PyThreadState* __tstate = wxPyBeginAllowThreads();
12485 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12497 PyObject *resultobj = 0;
12498 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12499 PyObject *arg2 = (PyObject *) 0 ;
12500 PyObject *arg3 = (PyObject *) 0 ;
12501 void *argp1 = 0 ;
12502 int res1 = 0 ;
12503 PyObject * obj0 = 0 ;
12504 PyObject * obj1 = 0 ;
12505 PyObject * obj2 = 0 ;
12506 char * kwnames[] = {
12507 (char *) "self",(char *) "self",(char *) "_class", NULL
12508 };
12509
12510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12512 if (!SWIG_IsOK(res1)) {
12513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12514 }
12515 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12516 arg2 = obj1;
12517 arg3 = obj2;
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 (arg1)->_setCallbackInfo(arg2,arg3);
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 resultobj = SWIG_Py_Void();
12525 return resultobj;
12526 fail:
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12532 PyObject *resultobj = 0;
12533 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12534 wxString *arg2 = 0 ;
12535 bool result;
12536 void *argp1 = 0 ;
12537 int res1 = 0 ;
12538 bool temp2 = false ;
12539 PyObject * obj0 = 0 ;
12540 PyObject * obj1 = 0 ;
12541 char * kwnames[] = {
12542 (char *) "self",(char *) "location", NULL
12543 };
12544
12545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12547 if (!SWIG_IsOK(res1)) {
12548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12549 }
12550 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12551 {
12552 arg2 = wxString_in_helper(obj1);
12553 if (arg2 == NULL) SWIG_fail;
12554 temp2 = true;
12555 }
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 {
12563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12564 }
12565 {
12566 if (temp2)
12567 delete arg2;
12568 }
12569 return resultobj;
12570 fail:
12571 {
12572 if (temp2)
12573 delete arg2;
12574 }
12575 return NULL;
12576 }
12577
12578
12579 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj = 0;
12581 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12582 wxFileSystem *arg2 = 0 ;
12583 wxString *arg3 = 0 ;
12584 wxFSFile *result = 0 ;
12585 void *argp1 = 0 ;
12586 int res1 = 0 ;
12587 void *argp2 = 0 ;
12588 int res2 = 0 ;
12589 bool temp3 = false ;
12590 PyObject * obj0 = 0 ;
12591 PyObject * obj1 = 0 ;
12592 PyObject * obj2 = 0 ;
12593 char * kwnames[] = {
12594 (char *) "self",(char *) "fs",(char *) "location", NULL
12595 };
12596
12597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12599 if (!SWIG_IsOK(res1)) {
12600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12601 }
12602 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12604 if (!SWIG_IsOK(res2)) {
12605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12606 }
12607 if (!argp2) {
12608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12609 }
12610 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12611 {
12612 arg3 = wxString_in_helper(obj2);
12613 if (arg3 == NULL) SWIG_fail;
12614 temp3 = true;
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12624 }
12625 {
12626 if (temp3)
12627 delete arg3;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp3)
12633 delete arg3;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12642 wxString *arg2 = 0 ;
12643 int arg3 = (int) 0 ;
12644 wxString result;
12645 void *argp1 = 0 ;
12646 int res1 = 0 ;
12647 bool temp2 = false ;
12648 int val3 ;
12649 int ecode3 = 0 ;
12650 PyObject * obj0 = 0 ;
12651 PyObject * obj1 = 0 ;
12652 PyObject * obj2 = 0 ;
12653 char * kwnames[] = {
12654 (char *) "self",(char *) "spec",(char *) "flags", NULL
12655 };
12656
12657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12659 if (!SWIG_IsOK(res1)) {
12660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12661 }
12662 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12663 {
12664 arg2 = wxString_in_helper(obj1);
12665 if (arg2 == NULL) SWIG_fail;
12666 temp2 = true;
12667 }
12668 if (obj2) {
12669 ecode3 = SWIG_AsVal_int(obj2, &val3);
12670 if (!SWIG_IsOK(ecode3)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12672 }
12673 arg3 = static_cast< int >(val3);
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 {
12682 #if wxUSE_UNICODE
12683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12684 #else
12685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12686 #endif
12687 }
12688 {
12689 if (temp2)
12690 delete arg2;
12691 }
12692 return resultobj;
12693 fail:
12694 {
12695 if (temp2)
12696 delete arg2;
12697 }
12698 return NULL;
12699 }
12700
12701
12702 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12703 PyObject *resultobj = 0;
12704 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12705 wxString result;
12706 void *argp1 = 0 ;
12707 int res1 = 0 ;
12708 PyObject *swig_obj[1] ;
12709
12710 if (!args) SWIG_fail;
12711 swig_obj[0] = args;
12712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12713 if (!SWIG_IsOK(res1)) {
12714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12715 }
12716 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 result = (arg1)->FindNext();
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 {
12724 #if wxUSE_UNICODE
12725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12726 #else
12727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12728 #endif
12729 }
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12737 PyObject *resultobj = 0;
12738 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12739 wxString *arg2 = 0 ;
12740 wxString result;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 bool temp2 = false ;
12744 PyObject * obj0 = 0 ;
12745 PyObject * obj1 = 0 ;
12746 char * kwnames[] = {
12747 (char *) "self",(char *) "location", NULL
12748 };
12749
12750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12752 if (!SWIG_IsOK(res1)) {
12753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12754 }
12755 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12756 {
12757 arg2 = wxString_in_helper(obj1);
12758 if (arg2 == NULL) SWIG_fail;
12759 temp2 = true;
12760 }
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 result = (arg1)->GetProtocol((wxString const &)*arg2);
12764 wxPyEndAllowThreads(__tstate);
12765 if (PyErr_Occurred()) SWIG_fail;
12766 }
12767 {
12768 #if wxUSE_UNICODE
12769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12770 #else
12771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12772 #endif
12773 }
12774 {
12775 if (temp2)
12776 delete arg2;
12777 }
12778 return resultobj;
12779 fail:
12780 {
12781 if (temp2)
12782 delete arg2;
12783 }
12784 return NULL;
12785 }
12786
12787
12788 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12789 PyObject *resultobj = 0;
12790 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12791 wxString *arg2 = 0 ;
12792 wxString result;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 bool temp2 = false ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 char * kwnames[] = {
12799 (char *) "self",(char *) "location", NULL
12800 };
12801
12802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12804 if (!SWIG_IsOK(res1)) {
12805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12806 }
12807 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12808 {
12809 arg2 = wxString_in_helper(obj1);
12810 if (arg2 == NULL) SWIG_fail;
12811 temp2 = true;
12812 }
12813 {
12814 PyThreadState* __tstate = wxPyBeginAllowThreads();
12815 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12816 wxPyEndAllowThreads(__tstate);
12817 if (PyErr_Occurred()) SWIG_fail;
12818 }
12819 {
12820 #if wxUSE_UNICODE
12821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12822 #else
12823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12824 #endif
12825 }
12826 {
12827 if (temp2)
12828 delete arg2;
12829 }
12830 return resultobj;
12831 fail:
12832 {
12833 if (temp2)
12834 delete arg2;
12835 }
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12841 PyObject *resultobj = 0;
12842 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12843 wxString *arg2 = 0 ;
12844 wxString result;
12845 void *argp1 = 0 ;
12846 int res1 = 0 ;
12847 bool temp2 = false ;
12848 PyObject * obj0 = 0 ;
12849 PyObject * obj1 = 0 ;
12850 char * kwnames[] = {
12851 (char *) "self",(char *) "location", NULL
12852 };
12853
12854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12856 if (!SWIG_IsOK(res1)) {
12857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12858 }
12859 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12860 {
12861 arg2 = wxString_in_helper(obj1);
12862 if (arg2 == NULL) SWIG_fail;
12863 temp2 = true;
12864 }
12865 {
12866 PyThreadState* __tstate = wxPyBeginAllowThreads();
12867 result = (arg1)->GetAnchor((wxString const &)*arg2);
12868 wxPyEndAllowThreads(__tstate);
12869 if (PyErr_Occurred()) SWIG_fail;
12870 }
12871 {
12872 #if wxUSE_UNICODE
12873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12874 #else
12875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12876 #endif
12877 }
12878 {
12879 if (temp2)
12880 delete arg2;
12881 }
12882 return resultobj;
12883 fail:
12884 {
12885 if (temp2)
12886 delete arg2;
12887 }
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12893 PyObject *resultobj = 0;
12894 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12895 wxString *arg2 = 0 ;
12896 wxString result;
12897 void *argp1 = 0 ;
12898 int res1 = 0 ;
12899 bool temp2 = false ;
12900 PyObject * obj0 = 0 ;
12901 PyObject * obj1 = 0 ;
12902 char * kwnames[] = {
12903 (char *) "self",(char *) "location", NULL
12904 };
12905
12906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12908 if (!SWIG_IsOK(res1)) {
12909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12910 }
12911 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12912 {
12913 arg2 = wxString_in_helper(obj1);
12914 if (arg2 == NULL) SWIG_fail;
12915 temp2 = true;
12916 }
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12920 wxPyEndAllowThreads(__tstate);
12921 if (PyErr_Occurred()) SWIG_fail;
12922 }
12923 {
12924 #if wxUSE_UNICODE
12925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12926 #else
12927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12928 #endif
12929 }
12930 {
12931 if (temp2)
12932 delete arg2;
12933 }
12934 return resultobj;
12935 fail:
12936 {
12937 if (temp2)
12938 delete arg2;
12939 }
12940 return NULL;
12941 }
12942
12943
12944 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12945 PyObject *resultobj = 0;
12946 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12947 wxString *arg2 = 0 ;
12948 wxString result;
12949 void *argp1 = 0 ;
12950 int res1 = 0 ;
12951 bool temp2 = false ;
12952 PyObject * obj0 = 0 ;
12953 PyObject * obj1 = 0 ;
12954 char * kwnames[] = {
12955 (char *) "self",(char *) "location", NULL
12956 };
12957
12958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12960 if (!SWIG_IsOK(res1)) {
12961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12962 }
12963 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12964 {
12965 arg2 = wxString_in_helper(obj1);
12966 if (arg2 == NULL) SWIG_fail;
12967 temp2 = true;
12968 }
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 {
12976 #if wxUSE_UNICODE
12977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12978 #else
12979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12980 #endif
12981 }
12982 {
12983 if (temp2)
12984 delete arg2;
12985 }
12986 return resultobj;
12987 fail:
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *obj;
12998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12999 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13000 return SWIG_Py_Void();
13001 }
13002
13003 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 return SWIG_Python_InitShadowInstance(args);
13005 }
13006
13007 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 PyObject *resultobj = 0;
13009 wxFileSystem *result = 0 ;
13010
13011 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13012 {
13013 PyThreadState* __tstate = wxPyBeginAllowThreads();
13014 result = (wxFileSystem *)new wxFileSystem();
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13019 return resultobj;
13020 fail:
13021 return NULL;
13022 }
13023
13024
13025 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026 PyObject *resultobj = 0;
13027 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 PyObject *swig_obj[1] ;
13031
13032 if (!args) SWIG_fail;
13033 swig_obj[0] = args;
13034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13037 }
13038 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 delete arg1;
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_Py_Void();
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj = 0;
13055 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13056 wxString *arg2 = 0 ;
13057 bool arg3 = (bool) false ;
13058 void *argp1 = 0 ;
13059 int res1 = 0 ;
13060 bool temp2 = false ;
13061 bool val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13072 if (!SWIG_IsOK(res1)) {
13073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13074 }
13075 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13076 {
13077 arg2 = wxString_in_helper(obj1);
13078 if (arg2 == NULL) SWIG_fail;
13079 temp2 = true;
13080 }
13081 if (obj2) {
13082 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13083 if (!SWIG_IsOK(ecode3)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13085 }
13086 arg3 = static_cast< bool >(val3);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_Py_Void();
13095 {
13096 if (temp2)
13097 delete arg2;
13098 }
13099 return resultobj;
13100 fail:
13101 {
13102 if (temp2)
13103 delete arg2;
13104 }
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13110 PyObject *resultobj = 0;
13111 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13112 wxString result;
13113 void *argp1 = 0 ;
13114 int res1 = 0 ;
13115 PyObject *swig_obj[1] ;
13116
13117 if (!args) SWIG_fail;
13118 swig_obj[0] = args;
13119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13120 if (!SWIG_IsOK(res1)) {
13121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13122 }
13123 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13124 {
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 result = (arg1)->GetPath();
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 #if wxUSE_UNICODE
13132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13133 #else
13134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13135 #endif
13136 }
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13146 wxString *arg2 = 0 ;
13147 wxFSFile *result = 0 ;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 bool temp2 = false ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "self",(char *) "location", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13161 }
13162 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13163 {
13164 arg2 = wxString_in_helper(obj1);
13165 if (arg2 == NULL) SWIG_fail;
13166 temp2 = true;
13167 }
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 {
13175 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13176 }
13177 {
13178 if (temp2)
13179 delete arg2;
13180 }
13181 return resultobj;
13182 fail:
13183 {
13184 if (temp2)
13185 delete arg2;
13186 }
13187 return NULL;
13188 }
13189
13190
13191 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13192 PyObject *resultobj = 0;
13193 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13194 wxString *arg2 = 0 ;
13195 int arg3 = (int) 0 ;
13196 wxString result;
13197 void *argp1 = 0 ;
13198 int res1 = 0 ;
13199 bool temp2 = false ;
13200 int val3 ;
13201 int ecode3 = 0 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "self",(char *) "spec",(char *) "flags", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13213 }
13214 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13215 {
13216 arg2 = wxString_in_helper(obj1);
13217 if (arg2 == NULL) SWIG_fail;
13218 temp2 = true;
13219 }
13220 if (obj2) {
13221 ecode3 = SWIG_AsVal_int(obj2, &val3);
13222 if (!SWIG_IsOK(ecode3)) {
13223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13224 }
13225 arg3 = static_cast< int >(val3);
13226 }
13227 {
13228 PyThreadState* __tstate = wxPyBeginAllowThreads();
13229 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 {
13234 #if wxUSE_UNICODE
13235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13236 #else
13237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13238 #endif
13239 }
13240 {
13241 if (temp2)
13242 delete arg2;
13243 }
13244 return resultobj;
13245 fail:
13246 {
13247 if (temp2)
13248 delete arg2;
13249 }
13250 return NULL;
13251 }
13252
13253
13254 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13255 PyObject *resultobj = 0;
13256 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13257 wxString result;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 PyObject *swig_obj[1] ;
13261
13262 if (!args) SWIG_fail;
13263 swig_obj[0] = args;
13264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13265 if (!SWIG_IsOK(res1)) {
13266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13267 }
13268 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 result = (arg1)->FindNext();
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 {
13276 #if wxUSE_UNICODE
13277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13278 #else
13279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13280 #endif
13281 }
13282 return resultobj;
13283 fail:
13284 return NULL;
13285 }
13286
13287
13288 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13289 PyObject *resultobj = 0;
13290 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13291 int res1 = 0 ;
13292 PyObject * obj0 = 0 ;
13293 char * kwnames[] = {
13294 (char *) "handler", NULL
13295 };
13296
13297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13298 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13299 if (!SWIG_IsOK(res1)) {
13300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13301 }
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 wxFileSystem::AddHandler(arg1);
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 resultobj = SWIG_Py_Void();
13309 return resultobj;
13310 fail:
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13316 PyObject *resultobj = 0;
13317 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13318 wxFileSystemHandler *result = 0 ;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 PyObject * obj0 = 0 ;
13322 char * kwnames[] = {
13323 (char *) "handler", NULL
13324 };
13325
13326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13330 }
13331 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13346 PyObject *resultobj = 0;
13347
13348 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13349 {
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 wxFileSystem::CleanUpHandlers();
13352 wxPyEndAllowThreads(__tstate);
13353 if (PyErr_Occurred()) SWIG_fail;
13354 }
13355 resultobj = SWIG_Py_Void();
13356 return resultobj;
13357 fail:
13358 return NULL;
13359 }
13360
13361
13362 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13363 PyObject *resultobj = 0;
13364 wxString *arg1 = 0 ;
13365 wxString result;
13366 bool temp1 = false ;
13367 PyObject * obj0 = 0 ;
13368 char * kwnames[] = {
13369 (char *) "filename", NULL
13370 };
13371
13372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13373 {
13374 arg1 = wxString_in_helper(obj0);
13375 if (arg1 == NULL) SWIG_fail;
13376 temp1 = true;
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 {
13385 #if wxUSE_UNICODE
13386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13387 #else
13388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13389 #endif
13390 }
13391 {
13392 if (temp1)
13393 delete arg1;
13394 }
13395 return resultobj;
13396 fail:
13397 {
13398 if (temp1)
13399 delete arg1;
13400 }
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj = 0;
13407 wxString *arg1 = 0 ;
13408 wxString result;
13409 bool temp1 = false ;
13410 PyObject * obj0 = 0 ;
13411 char * kwnames[] = {
13412 (char *) "url", NULL
13413 };
13414
13415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13416 {
13417 arg1 = wxString_in_helper(obj0);
13418 if (arg1 == NULL) SWIG_fail;
13419 temp1 = true;
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 {
13428 #if wxUSE_UNICODE
13429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13430 #else
13431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13432 #endif
13433 }
13434 {
13435 if (temp1)
13436 delete arg1;
13437 }
13438 return resultobj;
13439 fail:
13440 {
13441 if (temp1)
13442 delete arg1;
13443 }
13444 return NULL;
13445 }
13446
13447
13448 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *obj;
13450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13451 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13452 return SWIG_Py_Void();
13453 }
13454
13455 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13456 return SWIG_Python_InitShadowInstance(args);
13457 }
13458
13459 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13460 PyObject *resultobj = 0;
13461 wxInternetFSHandler *result = 0 ;
13462
13463 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj = 0;
13479 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13480 wxString *arg2 = 0 ;
13481 bool result;
13482 void *argp1 = 0 ;
13483 int res1 = 0 ;
13484 bool temp2 = false ;
13485 PyObject * obj0 = 0 ;
13486 PyObject * obj1 = 0 ;
13487 char * kwnames[] = {
13488 (char *) "self",(char *) "location", NULL
13489 };
13490
13491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13493 if (!SWIG_IsOK(res1)) {
13494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13495 }
13496 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13497 {
13498 arg2 = wxString_in_helper(obj1);
13499 if (arg2 == NULL) SWIG_fail;
13500 temp2 = true;
13501 }
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 {
13509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13510 }
13511 {
13512 if (temp2)
13513 delete arg2;
13514 }
13515 return resultobj;
13516 fail:
13517 {
13518 if (temp2)
13519 delete arg2;
13520 }
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13528 wxFileSystem *arg2 = 0 ;
13529 wxString *arg3 = 0 ;
13530 wxFSFile *result = 0 ;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 void *argp2 = 0 ;
13534 int res2 = 0 ;
13535 bool temp3 = false ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 PyObject * obj2 = 0 ;
13539 char * kwnames[] = {
13540 (char *) "self",(char *) "fs",(char *) "location", NULL
13541 };
13542
13543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13545 if (!SWIG_IsOK(res1)) {
13546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13547 }
13548 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13550 if (!SWIG_IsOK(res2)) {
13551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13552 }
13553 if (!argp2) {
13554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13555 }
13556 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13557 {
13558 arg3 = wxString_in_helper(obj2);
13559 if (arg3 == NULL) SWIG_fail;
13560 temp3 = true;
13561 }
13562 {
13563 PyThreadState* __tstate = wxPyBeginAllowThreads();
13564 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13570 }
13571 {
13572 if (temp3)
13573 delete arg3;
13574 }
13575 return resultobj;
13576 fail:
13577 {
13578 if (temp3)
13579 delete arg3;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *obj;
13587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13588 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13589 return SWIG_Py_Void();
13590 }
13591
13592 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593 return SWIG_Python_InitShadowInstance(args);
13594 }
13595
13596 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13597 PyObject *resultobj = 0;
13598 wxZipFSHandler *result = 0 ;
13599
13600 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13601 {
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 result = (wxZipFSHandler *)new wxZipFSHandler();
13604 wxPyEndAllowThreads(__tstate);
13605 if (PyErr_Occurred()) SWIG_fail;
13606 }
13607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13608 return resultobj;
13609 fail:
13610 return NULL;
13611 }
13612
13613
13614 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13615 PyObject *resultobj = 0;
13616 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13617 wxString *arg2 = 0 ;
13618 bool result;
13619 void *argp1 = 0 ;
13620 int res1 = 0 ;
13621 bool temp2 = false ;
13622 PyObject * obj0 = 0 ;
13623 PyObject * obj1 = 0 ;
13624 char * kwnames[] = {
13625 (char *) "self",(char *) "location", NULL
13626 };
13627
13628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13630 if (!SWIG_IsOK(res1)) {
13631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13632 }
13633 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13634 {
13635 arg2 = wxString_in_helper(obj1);
13636 if (arg2 == NULL) SWIG_fail;
13637 temp2 = true;
13638 }
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 {
13646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13647 }
13648 {
13649 if (temp2)
13650 delete arg2;
13651 }
13652 return resultobj;
13653 fail:
13654 {
13655 if (temp2)
13656 delete arg2;
13657 }
13658 return NULL;
13659 }
13660
13661
13662 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj = 0;
13664 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13665 wxFileSystem *arg2 = 0 ;
13666 wxString *arg3 = 0 ;
13667 wxFSFile *result = 0 ;
13668 void *argp1 = 0 ;
13669 int res1 = 0 ;
13670 void *argp2 = 0 ;
13671 int res2 = 0 ;
13672 bool temp3 = false ;
13673 PyObject * obj0 = 0 ;
13674 PyObject * obj1 = 0 ;
13675 PyObject * obj2 = 0 ;
13676 char * kwnames[] = {
13677 (char *) "self",(char *) "fs",(char *) "location", NULL
13678 };
13679
13680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13682 if (!SWIG_IsOK(res1)) {
13683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13684 }
13685 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13686 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13687 if (!SWIG_IsOK(res2)) {
13688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13689 }
13690 if (!argp2) {
13691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13692 }
13693 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13694 {
13695 arg3 = wxString_in_helper(obj2);
13696 if (arg3 == NULL) SWIG_fail;
13697 temp3 = true;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13707 }
13708 {
13709 if (temp3)
13710 delete arg3;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp3)
13716 delete arg3;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj = 0;
13724 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13725 wxString *arg2 = 0 ;
13726 int arg3 = (int) 0 ;
13727 wxString result;
13728 void *argp1 = 0 ;
13729 int res1 = 0 ;
13730 bool temp2 = false ;
13731 int val3 ;
13732 int ecode3 = 0 ;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 PyObject * obj2 = 0 ;
13736 char * kwnames[] = {
13737 (char *) "self",(char *) "spec",(char *) "flags", NULL
13738 };
13739
13740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13744 }
13745 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13746 {
13747 arg2 = wxString_in_helper(obj1);
13748 if (arg2 == NULL) SWIG_fail;
13749 temp2 = true;
13750 }
13751 if (obj2) {
13752 ecode3 = SWIG_AsVal_int(obj2, &val3);
13753 if (!SWIG_IsOK(ecode3)) {
13754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13755 }
13756 arg3 = static_cast< int >(val3);
13757 }
13758 {
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13761 wxPyEndAllowThreads(__tstate);
13762 if (PyErr_Occurred()) SWIG_fail;
13763 }
13764 {
13765 #if wxUSE_UNICODE
13766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13767 #else
13768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13769 #endif
13770 }
13771 {
13772 if (temp2)
13773 delete arg2;
13774 }
13775 return resultobj;
13776 fail:
13777 {
13778 if (temp2)
13779 delete arg2;
13780 }
13781 return NULL;
13782 }
13783
13784
13785 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13786 PyObject *resultobj = 0;
13787 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13788 wxString result;
13789 void *argp1 = 0 ;
13790 int res1 = 0 ;
13791 PyObject *swig_obj[1] ;
13792
13793 if (!args) SWIG_fail;
13794 swig_obj[0] = args;
13795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13796 if (!SWIG_IsOK(res1)) {
13797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13798 }
13799 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 result = (arg1)->FindNext();
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 {
13807 #if wxUSE_UNICODE
13808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13809 #else
13810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13811 #endif
13812 }
13813 return resultobj;
13814 fail:
13815 return NULL;
13816 }
13817
13818
13819 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13820 PyObject *obj;
13821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13822 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13823 return SWIG_Py_Void();
13824 }
13825
13826 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13827 return SWIG_Python_InitShadowInstance(args);
13828 }
13829
13830 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13831 PyObject *resultobj = 0;
13832 wxString *arg1 = 0 ;
13833 wxImage *arg2 = 0 ;
13834 long arg3 ;
13835 bool temp1 = false ;
13836 void *argp2 = 0 ;
13837 int res2 = 0 ;
13838 long val3 ;
13839 int ecode3 = 0 ;
13840 PyObject * obj0 = 0 ;
13841 PyObject * obj1 = 0 ;
13842 PyObject * obj2 = 0 ;
13843 char * kwnames[] = {
13844 (char *) "filename",(char *) "image",(char *) "type", NULL
13845 };
13846
13847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13848 {
13849 arg1 = wxString_in_helper(obj0);
13850 if (arg1 == NULL) SWIG_fail;
13851 temp1 = true;
13852 }
13853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13854 if (!SWIG_IsOK(res2)) {
13855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13856 }
13857 if (!argp2) {
13858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13859 }
13860 arg2 = reinterpret_cast< wxImage * >(argp2);
13861 ecode3 = SWIG_AsVal_long(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13864 }
13865 arg3 = static_cast< long >(val3);
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 resultobj = SWIG_Py_Void();
13873 {
13874 if (temp1)
13875 delete arg1;
13876 }
13877 return resultobj;
13878 fail:
13879 {
13880 if (temp1)
13881 delete arg1;
13882 }
13883 return NULL;
13884 }
13885
13886
13887 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj = 0;
13889 wxString *arg1 = 0 ;
13890 wxBitmap *arg2 = 0 ;
13891 long arg3 ;
13892 bool temp1 = false ;
13893 void *argp2 = 0 ;
13894 int res2 = 0 ;
13895 long val3 ;
13896 int ecode3 = 0 ;
13897 PyObject * obj0 = 0 ;
13898 PyObject * obj1 = 0 ;
13899 PyObject * obj2 = 0 ;
13900 char * kwnames[] = {
13901 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13902 };
13903
13904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13905 {
13906 arg1 = wxString_in_helper(obj0);
13907 if (arg1 == NULL) SWIG_fail;
13908 temp1 = true;
13909 }
13910 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13911 if (!SWIG_IsOK(res2)) {
13912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13913 }
13914 if (!argp2) {
13915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13916 }
13917 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13918 ecode3 = SWIG_AsVal_long(obj2, &val3);
13919 if (!SWIG_IsOK(ecode3)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13921 }
13922 arg3 = static_cast< long >(val3);
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 resultobj = SWIG_Py_Void();
13930 {
13931 if (temp1)
13932 delete arg1;
13933 }
13934 return resultobj;
13935 fail:
13936 {
13937 if (temp1)
13938 delete arg1;
13939 }
13940 return NULL;
13941 }
13942
13943
13944 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj = 0;
13946 wxString *arg1 = 0 ;
13947 PyObject *arg2 = (PyObject *) 0 ;
13948 bool temp1 = false ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 char * kwnames[] = {
13952 (char *) "filename",(char *) "data", NULL
13953 };
13954
13955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13956 {
13957 arg1 = wxString_in_helper(obj0);
13958 if (arg1 == NULL) SWIG_fail;
13959 temp1 = true;
13960 }
13961 arg2 = obj1;
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 resultobj = SWIG_Py_Void();
13969 {
13970 if (temp1)
13971 delete arg1;
13972 }
13973 return resultobj;
13974 fail:
13975 {
13976 if (temp1)
13977 delete arg1;
13978 }
13979 return NULL;
13980 }
13981
13982
13983 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13984 PyObject *resultobj = 0;
13985 wxMemoryFSHandler *result = 0 ;
13986
13987 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13991 wxPyEndAllowThreads(__tstate);
13992 if (PyErr_Occurred()) SWIG_fail;
13993 }
13994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13995 return resultobj;
13996 fail:
13997 return NULL;
13998 }
13999
14000
14001 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj = 0;
14003 wxString *arg1 = 0 ;
14004 bool temp1 = false ;
14005 PyObject * obj0 = 0 ;
14006 char * kwnames[] = {
14007 (char *) "filename", NULL
14008 };
14009
14010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14011 {
14012 arg1 = wxString_in_helper(obj0);
14013 if (arg1 == NULL) SWIG_fail;
14014 temp1 = true;
14015 }
14016 {
14017 PyThreadState* __tstate = wxPyBeginAllowThreads();
14018 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 resultobj = SWIG_Py_Void();
14023 {
14024 if (temp1)
14025 delete arg1;
14026 }
14027 return resultobj;
14028 fail:
14029 {
14030 if (temp1)
14031 delete arg1;
14032 }
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj = 0;
14039 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14040 wxString *arg2 = 0 ;
14041 bool result;
14042 void *argp1 = 0 ;
14043 int res1 = 0 ;
14044 bool temp2 = false ;
14045 PyObject * obj0 = 0 ;
14046 PyObject * obj1 = 0 ;
14047 char * kwnames[] = {
14048 (char *) "self",(char *) "location", NULL
14049 };
14050
14051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14053 if (!SWIG_IsOK(res1)) {
14054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14055 }
14056 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14057 {
14058 arg2 = wxString_in_helper(obj1);
14059 if (arg2 == NULL) SWIG_fail;
14060 temp2 = true;
14061 }
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 {
14069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14070 }
14071 {
14072 if (temp2)
14073 delete arg2;
14074 }
14075 return resultobj;
14076 fail:
14077 {
14078 if (temp2)
14079 delete arg2;
14080 }
14081 return NULL;
14082 }
14083
14084
14085 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14086 PyObject *resultobj = 0;
14087 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14088 wxFileSystem *arg2 = 0 ;
14089 wxString *arg3 = 0 ;
14090 wxFSFile *result = 0 ;
14091 void *argp1 = 0 ;
14092 int res1 = 0 ;
14093 void *argp2 = 0 ;
14094 int res2 = 0 ;
14095 bool temp3 = false ;
14096 PyObject * obj0 = 0 ;
14097 PyObject * obj1 = 0 ;
14098 PyObject * obj2 = 0 ;
14099 char * kwnames[] = {
14100 (char *) "self",(char *) "fs",(char *) "location", NULL
14101 };
14102
14103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14105 if (!SWIG_IsOK(res1)) {
14106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14107 }
14108 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14110 if (!SWIG_IsOK(res2)) {
14111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14112 }
14113 if (!argp2) {
14114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14115 }
14116 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14117 {
14118 arg3 = wxString_in_helper(obj2);
14119 if (arg3 == NULL) SWIG_fail;
14120 temp3 = true;
14121 }
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14130 }
14131 {
14132 if (temp3)
14133 delete arg3;
14134 }
14135 return resultobj;
14136 fail:
14137 {
14138 if (temp3)
14139 delete arg3;
14140 }
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14148 wxString *arg2 = 0 ;
14149 int arg3 = (int) 0 ;
14150 wxString result;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 bool temp2 = false ;
14154 int val3 ;
14155 int ecode3 = 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 PyObject * obj2 = 0 ;
14159 char * kwnames[] = {
14160 (char *) "self",(char *) "spec",(char *) "flags", NULL
14161 };
14162
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14167 }
14168 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14169 {
14170 arg2 = wxString_in_helper(obj1);
14171 if (arg2 == NULL) SWIG_fail;
14172 temp2 = true;
14173 }
14174 if (obj2) {
14175 ecode3 = SWIG_AsVal_int(obj2, &val3);
14176 if (!SWIG_IsOK(ecode3)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14178 }
14179 arg3 = static_cast< int >(val3);
14180 }
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 {
14188 #if wxUSE_UNICODE
14189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14190 #else
14191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14192 #endif
14193 }
14194 {
14195 if (temp2)
14196 delete arg2;
14197 }
14198 return resultobj;
14199 fail:
14200 {
14201 if (temp2)
14202 delete arg2;
14203 }
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14209 PyObject *resultobj = 0;
14210 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14211 wxString result;
14212 void *argp1 = 0 ;
14213 int res1 = 0 ;
14214 PyObject *swig_obj[1] ;
14215
14216 if (!args) SWIG_fail;
14217 swig_obj[0] = args;
14218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14221 }
14222 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 result = (arg1)->FindNext();
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 {
14230 #if wxUSE_UNICODE
14231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14232 #else
14233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14234 #endif
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *obj;
14244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14245 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14246 return SWIG_Py_Void();
14247 }
14248
14249 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14250 return SWIG_Python_InitShadowInstance(args);
14251 }
14252
14253 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14254 PyObject *resultobj = 0;
14255 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14256 wxString result;
14257 void *argp1 = 0 ;
14258 int res1 = 0 ;
14259 PyObject *swig_obj[1] ;
14260
14261 if (!args) SWIG_fail;
14262 swig_obj[0] = args;
14263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14264 if (!SWIG_IsOK(res1)) {
14265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14266 }
14267 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14268 {
14269 PyThreadState* __tstate = wxPyBeginAllowThreads();
14270 result = (arg1)->GetName();
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 {
14275 #if wxUSE_UNICODE
14276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14277 #else
14278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14279 #endif
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14288 PyObject *resultobj = 0;
14289 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14290 wxString result;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 PyObject *swig_obj[1] ;
14294
14295 if (!args) SWIG_fail;
14296 swig_obj[0] = args;
14297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14300 }
14301 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 result = (arg1)->GetExtension();
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 {
14309 #if wxUSE_UNICODE
14310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14311 #else
14312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14313 #endif
14314 }
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14322 PyObject *resultobj = 0;
14323 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14324 long result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 PyObject *swig_obj[1] ;
14328
14329 if (!args) SWIG_fail;
14330 swig_obj[0] = args;
14331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14332 if (!SWIG_IsOK(res1)) {
14333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14334 }
14335 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 result = (long)(arg1)->GetType();
14339 wxPyEndAllowThreads(__tstate);
14340 if (PyErr_Occurred()) SWIG_fail;
14341 }
14342 resultobj = SWIG_From_long(static_cast< long >(result));
14343 return resultobj;
14344 fail:
14345 return NULL;
14346 }
14347
14348
14349 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14350 PyObject *resultobj = 0;
14351 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14352 wxString result;
14353 void *argp1 = 0 ;
14354 int res1 = 0 ;
14355 PyObject *swig_obj[1] ;
14356
14357 if (!args) SWIG_fail;
14358 swig_obj[0] = args;
14359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14360 if (!SWIG_IsOK(res1)) {
14361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14362 }
14363 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (arg1)->GetMimeType();
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 {
14371 #if wxUSE_UNICODE
14372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14373 #else
14374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14375 #endif
14376 }
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = 0;
14385 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14386 wxString *arg2 = 0 ;
14387 bool result;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 bool temp2 = false ;
14391 PyObject * obj0 = 0 ;
14392 PyObject * obj1 = 0 ;
14393 char * kwnames[] = {
14394 (char *) "self",(char *) "name", NULL
14395 };
14396
14397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14401 }
14402 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14403 {
14404 arg2 = wxString_in_helper(obj1);
14405 if (arg2 == NULL) SWIG_fail;
14406 temp2 = true;
14407 }
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 {
14415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14416 }
14417 {
14418 if (temp2)
14419 delete arg2;
14420 }
14421 return resultobj;
14422 fail:
14423 {
14424 if (temp2)
14425 delete arg2;
14426 }
14427 return NULL;
14428 }
14429
14430
14431 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj = 0;
14433 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14434 wxInputStream *arg2 = 0 ;
14435 bool result;
14436 void *argp1 = 0 ;
14437 int res1 = 0 ;
14438 wxPyInputStream *temp2 ;
14439 bool created2 ;
14440 PyObject * obj0 = 0 ;
14441 PyObject * obj1 = 0 ;
14442 char * kwnames[] = {
14443 (char *) "self",(char *) "stream", NULL
14444 };
14445
14446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14448 if (!SWIG_IsOK(res1)) {
14449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14450 }
14451 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14452 {
14453 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14454 arg2 = temp2->m_wxis;
14455 created2 = false;
14456 } else {
14457 PyErr_Clear(); // clear the failure of the wxPyConvert above
14458 arg2 = wxPyCBInputStream_create(obj1, false);
14459 if (arg2 == NULL) {
14460 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14461 SWIG_fail;
14462 }
14463 created2 = true;
14464 }
14465 }
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 result = (bool)(arg1)->CanRead(*arg2);
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 {
14473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14474 }
14475 {
14476 if (created2) delete arg2;
14477 }
14478 return resultobj;
14479 fail:
14480 {
14481 if (created2) delete arg2;
14482 }
14483 return NULL;
14484 }
14485
14486
14487 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14488 PyObject *resultobj = 0;
14489 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14490 wxString *arg2 = 0 ;
14491 void *argp1 = 0 ;
14492 int res1 = 0 ;
14493 bool temp2 = false ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 char * kwnames[] = {
14497 (char *) "self",(char *) "name", NULL
14498 };
14499
14500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14502 if (!SWIG_IsOK(res1)) {
14503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14504 }
14505 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14506 {
14507 arg2 = wxString_in_helper(obj1);
14508 if (arg2 == NULL) SWIG_fail;
14509 temp2 = true;
14510 }
14511 {
14512 PyThreadState* __tstate = wxPyBeginAllowThreads();
14513 (arg1)->SetName((wxString const &)*arg2);
14514 wxPyEndAllowThreads(__tstate);
14515 if (PyErr_Occurred()) SWIG_fail;
14516 }
14517 resultobj = SWIG_Py_Void();
14518 {
14519 if (temp2)
14520 delete arg2;
14521 }
14522 return resultobj;
14523 fail:
14524 {
14525 if (temp2)
14526 delete arg2;
14527 }
14528 return NULL;
14529 }
14530
14531
14532 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14533 PyObject *resultobj = 0;
14534 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14535 wxString *arg2 = 0 ;
14536 void *argp1 = 0 ;
14537 int res1 = 0 ;
14538 bool temp2 = false ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 char * kwnames[] = {
14542 (char *) "self",(char *) "extension", NULL
14543 };
14544
14545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14547 if (!SWIG_IsOK(res1)) {
14548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14549 }
14550 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14551 {
14552 arg2 = wxString_in_helper(obj1);
14553 if (arg2 == NULL) SWIG_fail;
14554 temp2 = true;
14555 }
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 (arg1)->SetExtension((wxString const &)*arg2);
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_Py_Void();
14563 {
14564 if (temp2)
14565 delete arg2;
14566 }
14567 return resultobj;
14568 fail:
14569 {
14570 if (temp2)
14571 delete arg2;
14572 }
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14578 PyObject *resultobj = 0;
14579 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14580 long arg2 ;
14581 void *argp1 = 0 ;
14582 int res1 = 0 ;
14583 long val2 ;
14584 int ecode2 = 0 ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 char * kwnames[] = {
14588 (char *) "self",(char *) "type", NULL
14589 };
14590
14591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14593 if (!SWIG_IsOK(res1)) {
14594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14595 }
14596 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14597 ecode2 = SWIG_AsVal_long(obj1, &val2);
14598 if (!SWIG_IsOK(ecode2)) {
14599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14600 }
14601 arg2 = static_cast< long >(val2);
14602 {
14603 PyThreadState* __tstate = wxPyBeginAllowThreads();
14604 (arg1)->SetType(arg2);
14605 wxPyEndAllowThreads(__tstate);
14606 if (PyErr_Occurred()) SWIG_fail;
14607 }
14608 resultobj = SWIG_Py_Void();
14609 return resultobj;
14610 fail:
14611 return NULL;
14612 }
14613
14614
14615 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14616 PyObject *resultobj = 0;
14617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14618 wxString *arg2 = 0 ;
14619 void *argp1 = 0 ;
14620 int res1 = 0 ;
14621 bool temp2 = false ;
14622 PyObject * obj0 = 0 ;
14623 PyObject * obj1 = 0 ;
14624 char * kwnames[] = {
14625 (char *) "self",(char *) "mimetype", NULL
14626 };
14627
14628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14630 if (!SWIG_IsOK(res1)) {
14631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14632 }
14633 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14634 {
14635 arg2 = wxString_in_helper(obj1);
14636 if (arg2 == NULL) SWIG_fail;
14637 temp2 = true;
14638 }
14639 {
14640 PyThreadState* __tstate = wxPyBeginAllowThreads();
14641 (arg1)->SetMimeType((wxString const &)*arg2);
14642 wxPyEndAllowThreads(__tstate);
14643 if (PyErr_Occurred()) SWIG_fail;
14644 }
14645 resultobj = SWIG_Py_Void();
14646 {
14647 if (temp2)
14648 delete arg2;
14649 }
14650 return resultobj;
14651 fail:
14652 {
14653 if (temp2)
14654 delete arg2;
14655 }
14656 return NULL;
14657 }
14658
14659
14660 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14661 PyObject *obj;
14662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14663 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14664 return SWIG_Py_Void();
14665 }
14666
14667 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668 PyObject *resultobj = 0;
14669 wxPyImageHandler *result = 0 ;
14670
14671 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (wxPyImageHandler *)new wxPyImageHandler();
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14679 return resultobj;
14680 fail:
14681 return NULL;
14682 }
14683
14684
14685 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14686 PyObject *resultobj = 0;
14687 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14688 PyObject *arg2 = (PyObject *) 0 ;
14689 void *argp1 = 0 ;
14690 int res1 = 0 ;
14691 PyObject * obj0 = 0 ;
14692 PyObject * obj1 = 0 ;
14693 char * kwnames[] = {
14694 (char *) "self",(char *) "self", NULL
14695 };
14696
14697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14699 if (!SWIG_IsOK(res1)) {
14700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14701 }
14702 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14703 arg2 = obj1;
14704 {
14705 PyThreadState* __tstate = wxPyBeginAllowThreads();
14706 (arg1)->_SetSelf(arg2);
14707 wxPyEndAllowThreads(__tstate);
14708 if (PyErr_Occurred()) SWIG_fail;
14709 }
14710 resultobj = SWIG_Py_Void();
14711 return resultobj;
14712 fail:
14713 return NULL;
14714 }
14715
14716
14717 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *obj;
14719 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14720 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14721 return SWIG_Py_Void();
14722 }
14723
14724 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14725 return SWIG_Python_InitShadowInstance(args);
14726 }
14727
14728 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14729 PyObject *resultobj = 0;
14730 wxImageHistogram *result = 0 ;
14731
14732 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (wxImageHistogram *)new wxImageHistogram();
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj = 0;
14748 byte arg1 ;
14749 byte arg2 ;
14750 byte arg3 ;
14751 unsigned long result;
14752 unsigned char val1 ;
14753 int ecode1 = 0 ;
14754 unsigned char val2 ;
14755 int ecode2 = 0 ;
14756 unsigned char val3 ;
14757 int ecode3 = 0 ;
14758 PyObject * obj0 = 0 ;
14759 PyObject * obj1 = 0 ;
14760 PyObject * obj2 = 0 ;
14761 char * kwnames[] = {
14762 (char *) "r",(char *) "g",(char *) "b", NULL
14763 };
14764
14765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14766 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14767 if (!SWIG_IsOK(ecode1)) {
14768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14769 }
14770 arg1 = static_cast< byte >(val1);
14771 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14772 if (!SWIG_IsOK(ecode2)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14774 }
14775 arg2 = static_cast< byte >(val2);
14776 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14777 if (!SWIG_IsOK(ecode3)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14779 }
14780 arg3 = static_cast< byte >(val3);
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj = 0;
14796 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14797 byte *arg2 = (byte *) 0 ;
14798 byte *arg3 = (byte *) 0 ;
14799 byte *arg4 = (byte *) 0 ;
14800 byte arg5 = (byte) 1 ;
14801 byte arg6 = (byte) 0 ;
14802 byte arg7 = (byte) 0 ;
14803 bool result;
14804 void *argp1 = 0 ;
14805 int res1 = 0 ;
14806 byte temp2 ;
14807 int res2 = SWIG_TMPOBJ ;
14808 byte temp3 ;
14809 int res3 = SWIG_TMPOBJ ;
14810 byte temp4 ;
14811 int res4 = SWIG_TMPOBJ ;
14812 unsigned char val5 ;
14813 int ecode5 = 0 ;
14814 unsigned char val6 ;
14815 int ecode6 = 0 ;
14816 unsigned char val7 ;
14817 int ecode7 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 PyObject * obj3 = 0 ;
14822 char * kwnames[] = {
14823 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14824 };
14825
14826 arg2 = &temp2;
14827 arg3 = &temp3;
14828 arg4 = &temp4;
14829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14833 }
14834 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14835 if (obj1) {
14836 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14837 if (!SWIG_IsOK(ecode5)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14839 }
14840 arg5 = static_cast< byte >(val5);
14841 }
14842 if (obj2) {
14843 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14844 if (!SWIG_IsOK(ecode6)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14846 }
14847 arg6 = static_cast< byte >(val6);
14848 }
14849 if (obj3) {
14850 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14851 if (!SWIG_IsOK(ecode7)) {
14852 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14853 }
14854 arg7 = static_cast< byte >(val7);
14855 }
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 {
14863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14864 }
14865 if (SWIG_IsTmpObj(res2)) {
14866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14867 } else {
14868 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14870 }
14871 if (SWIG_IsTmpObj(res3)) {
14872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14873 } else {
14874 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14876 }
14877 if (SWIG_IsTmpObj(res4)) {
14878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14879 } else {
14880 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14882 }
14883 return resultobj;
14884 fail:
14885 return NULL;
14886 }
14887
14888
14889 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj = 0;
14891 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14892 unsigned long arg2 ;
14893 unsigned long result;
14894 void *argp1 = 0 ;
14895 int res1 = 0 ;
14896 unsigned long val2 ;
14897 int ecode2 = 0 ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 char * kwnames[] = {
14901 (char *) "self",(char *) "key", NULL
14902 };
14903
14904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14906 if (!SWIG_IsOK(res1)) {
14907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14908 }
14909 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14910 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14911 if (!SWIG_IsOK(ecode2)) {
14912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14913 }
14914 arg2 = static_cast< unsigned long >(val2);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj = 0;
14930 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14931 byte arg2 ;
14932 byte arg3 ;
14933 byte arg4 ;
14934 unsigned long result;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 unsigned char val2 ;
14938 int ecode2 = 0 ;
14939 unsigned char val3 ;
14940 int ecode3 = 0 ;
14941 unsigned char val4 ;
14942 int ecode4 = 0 ;
14943 PyObject * obj0 = 0 ;
14944 PyObject * obj1 = 0 ;
14945 PyObject * obj2 = 0 ;
14946 PyObject * obj3 = 0 ;
14947 char * kwnames[] = {
14948 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14949 };
14950
14951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14953 if (!SWIG_IsOK(res1)) {
14954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14955 }
14956 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14957 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14958 if (!SWIG_IsOK(ecode2)) {
14959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14960 }
14961 arg2 = static_cast< byte >(val2);
14962 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14963 if (!SWIG_IsOK(ecode3)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14965 }
14966 arg3 = static_cast< byte >(val3);
14967 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14968 if (!SWIG_IsOK(ecode4)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14970 }
14971 arg4 = static_cast< byte >(val4);
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj = 0;
14987 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14988 wxColour *arg2 = 0 ;
14989 unsigned long result;
14990 void *argp1 = 0 ;
14991 int res1 = 0 ;
14992 wxColour temp2 ;
14993 PyObject * obj0 = 0 ;
14994 PyObject * obj1 = 0 ;
14995 char * kwnames[] = {
14996 (char *) "self",(char *) "colour", NULL
14997 };
14998
14999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15001 if (!SWIG_IsOK(res1)) {
15002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15003 }
15004 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15005 {
15006 arg2 = &temp2;
15007 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15008 }
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15023 PyObject *obj;
15024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15025 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15026 return SWIG_Py_Void();
15027 }
15028
15029 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 return SWIG_Python_InitShadowInstance(args);
15031 }
15032
15033 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj = 0;
15035 byte arg1 = (byte) 0 ;
15036 byte arg2 = (byte) 0 ;
15037 byte arg3 = (byte) 0 ;
15038 wxImage_RGBValue *result = 0 ;
15039 unsigned char val1 ;
15040 int ecode1 = 0 ;
15041 unsigned char val2 ;
15042 int ecode2 = 0 ;
15043 unsigned char val3 ;
15044 int ecode3 = 0 ;
15045 PyObject * obj0 = 0 ;
15046 PyObject * obj1 = 0 ;
15047 PyObject * obj2 = 0 ;
15048 char * kwnames[] = {
15049 (char *) "r",(char *) "g",(char *) "b", NULL
15050 };
15051
15052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15053 if (obj0) {
15054 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15055 if (!SWIG_IsOK(ecode1)) {
15056 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15057 }
15058 arg1 = static_cast< byte >(val1);
15059 }
15060 if (obj1) {
15061 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15062 if (!SWIG_IsOK(ecode2)) {
15063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15064 }
15065 arg2 = static_cast< byte >(val2);
15066 }
15067 if (obj2) {
15068 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15069 if (!SWIG_IsOK(ecode3)) {
15070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15071 }
15072 arg3 = static_cast< byte >(val3);
15073 }
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15088 PyObject *resultobj = 0;
15089 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15090 byte arg2 ;
15091 void *argp1 = 0 ;
15092 int res1 = 0 ;
15093 unsigned char val2 ;
15094 int ecode2 = 0 ;
15095 PyObject *swig_obj[2] ;
15096
15097 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15101 }
15102 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15103 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15104 if (!SWIG_IsOK(ecode2)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15106 }
15107 arg2 = static_cast< byte >(val2);
15108 if (arg1) (arg1)->red = arg2;
15109
15110 resultobj = SWIG_Py_Void();
15111 return resultobj;
15112 fail:
15113 return NULL;
15114 }
15115
15116
15117 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15118 PyObject *resultobj = 0;
15119 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15120 byte result;
15121 void *argp1 = 0 ;
15122 int res1 = 0 ;
15123 PyObject *swig_obj[1] ;
15124
15125 if (!args) SWIG_fail;
15126 swig_obj[0] = args;
15127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15128 if (!SWIG_IsOK(res1)) {
15129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15130 }
15131 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15132 result = (byte) ((arg1)->red);
15133 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15141 PyObject *resultobj = 0;
15142 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15143 byte arg2 ;
15144 void *argp1 = 0 ;
15145 int res1 = 0 ;
15146 unsigned char val2 ;
15147 int ecode2 = 0 ;
15148 PyObject *swig_obj[2] ;
15149
15150 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15152 if (!SWIG_IsOK(res1)) {
15153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15154 }
15155 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15156 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15157 if (!SWIG_IsOK(ecode2)) {
15158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15159 }
15160 arg2 = static_cast< byte >(val2);
15161 if (arg1) (arg1)->green = arg2;
15162
15163 resultobj = SWIG_Py_Void();
15164 return resultobj;
15165 fail:
15166 return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171 PyObject *resultobj = 0;
15172 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15173 byte result;
15174 void *argp1 = 0 ;
15175 int res1 = 0 ;
15176 PyObject *swig_obj[1] ;
15177
15178 if (!args) SWIG_fail;
15179 swig_obj[0] = args;
15180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15181 if (!SWIG_IsOK(res1)) {
15182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15183 }
15184 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15185 result = (byte) ((arg1)->green);
15186 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15196 byte arg2 ;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 unsigned char val2 ;
15200 int ecode2 = 0 ;
15201 PyObject *swig_obj[2] ;
15202
15203 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15207 }
15208 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15209 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15210 if (!SWIG_IsOK(ecode2)) {
15211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15212 }
15213 arg2 = static_cast< byte >(val2);
15214 if (arg1) (arg1)->blue = arg2;
15215
15216 resultobj = SWIG_Py_Void();
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15226 byte result;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject *swig_obj[1] ;
15230
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15236 }
15237 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15238 result = (byte) ((arg1)->blue);
15239 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *obj;
15248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15249 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15250 return SWIG_Py_Void();
15251 }
15252
15253 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15254 return SWIG_Python_InitShadowInstance(args);
15255 }
15256
15257 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15258 PyObject *resultobj = 0;
15259 double arg1 = (double) 0.0 ;
15260 double arg2 = (double) 0.0 ;
15261 double arg3 = (double) 0.0 ;
15262 wxImage_HSVValue *result = 0 ;
15263 double val1 ;
15264 int ecode1 = 0 ;
15265 double val2 ;
15266 int ecode2 = 0 ;
15267 double val3 ;
15268 int ecode3 = 0 ;
15269 PyObject * obj0 = 0 ;
15270 PyObject * obj1 = 0 ;
15271 PyObject * obj2 = 0 ;
15272 char * kwnames[] = {
15273 (char *) "h",(char *) "s",(char *) "v", NULL
15274 };
15275
15276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15277 if (obj0) {
15278 ecode1 = SWIG_AsVal_double(obj0, &val1);
15279 if (!SWIG_IsOK(ecode1)) {
15280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15281 }
15282 arg1 = static_cast< double >(val1);
15283 }
15284 if (obj1) {
15285 ecode2 = SWIG_AsVal_double(obj1, &val2);
15286 if (!SWIG_IsOK(ecode2)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15288 }
15289 arg2 = static_cast< double >(val2);
15290 }
15291 if (obj2) {
15292 ecode3 = SWIG_AsVal_double(obj2, &val3);
15293 if (!SWIG_IsOK(ecode3)) {
15294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15295 }
15296 arg3 = static_cast< double >(val3);
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15312 PyObject *resultobj = 0;
15313 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15314 double arg2 ;
15315 void *argp1 = 0 ;
15316 int res1 = 0 ;
15317 double val2 ;
15318 int ecode2 = 0 ;
15319 PyObject *swig_obj[2] ;
15320
15321 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15327 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15328 if (!SWIG_IsOK(ecode2)) {
15329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15330 }
15331 arg2 = static_cast< double >(val2);
15332 if (arg1) (arg1)->hue = arg2;
15333
15334 resultobj = SWIG_Py_Void();
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15342 PyObject *resultobj = 0;
15343 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15344 double result;
15345 void *argp1 = 0 ;
15346 int res1 = 0 ;
15347 PyObject *swig_obj[1] ;
15348
15349 if (!args) SWIG_fail;
15350 swig_obj[0] = args;
15351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15352 if (!SWIG_IsOK(res1)) {
15353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15354 }
15355 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15356 result = (double) ((arg1)->hue);
15357 resultobj = SWIG_From_double(static_cast< double >(result));
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15365 PyObject *resultobj = 0;
15366 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15367 double arg2 ;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 double val2 ;
15371 int ecode2 = 0 ;
15372 PyObject *swig_obj[2] ;
15373
15374 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15376 if (!SWIG_IsOK(res1)) {
15377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15378 }
15379 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15380 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15381 if (!SWIG_IsOK(ecode2)) {
15382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15383 }
15384 arg2 = static_cast< double >(val2);
15385 if (arg1) (arg1)->saturation = arg2;
15386
15387 resultobj = SWIG_Py_Void();
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15395 PyObject *resultobj = 0;
15396 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15397 double result;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 PyObject *swig_obj[1] ;
15401
15402 if (!args) SWIG_fail;
15403 swig_obj[0] = args;
15404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15405 if (!SWIG_IsOK(res1)) {
15406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15407 }
15408 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15409 result = (double) ((arg1)->saturation);
15410 resultobj = SWIG_From_double(static_cast< double >(result));
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418 PyObject *resultobj = 0;
15419 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15420 double arg2 ;
15421 void *argp1 = 0 ;
15422 int res1 = 0 ;
15423 double val2 ;
15424 int ecode2 = 0 ;
15425 PyObject *swig_obj[2] ;
15426
15427 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15429 if (!SWIG_IsOK(res1)) {
15430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15431 }
15432 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15433 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15434 if (!SWIG_IsOK(ecode2)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15436 }
15437 arg2 = static_cast< double >(val2);
15438 if (arg1) (arg1)->value = arg2;
15439
15440 resultobj = SWIG_Py_Void();
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15448 PyObject *resultobj = 0;
15449 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15450 double result;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject *swig_obj[1] ;
15454
15455 if (!args) SWIG_fail;
15456 swig_obj[0] = args;
15457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15460 }
15461 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15462 result = (double) ((arg1)->value);
15463 resultobj = SWIG_From_double(static_cast< double >(result));
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15471 PyObject *obj;
15472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15473 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15474 return SWIG_Py_Void();
15475 }
15476
15477 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 return SWIG_Python_InitShadowInstance(args);
15479 }
15480
15481 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15482 PyObject *resultobj = 0;
15483 wxString *arg1 = 0 ;
15484 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15485 int arg3 = (int) -1 ;
15486 wxImage *result = 0 ;
15487 bool temp1 = false ;
15488 long val2 ;
15489 int ecode2 = 0 ;
15490 int val3 ;
15491 int ecode3 = 0 ;
15492 PyObject * obj0 = 0 ;
15493 PyObject * obj1 = 0 ;
15494 PyObject * obj2 = 0 ;
15495 char * kwnames[] = {
15496 (char *) "name",(char *) "type",(char *) "index", NULL
15497 };
15498
15499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15500 {
15501 arg1 = wxString_in_helper(obj0);
15502 if (arg1 == NULL) SWIG_fail;
15503 temp1 = true;
15504 }
15505 if (obj1) {
15506 ecode2 = SWIG_AsVal_long(obj1, &val2);
15507 if (!SWIG_IsOK(ecode2)) {
15508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15509 }
15510 arg2 = static_cast< long >(val2);
15511 }
15512 if (obj2) {
15513 ecode3 = SWIG_AsVal_int(obj2, &val3);
15514 if (!SWIG_IsOK(ecode3)) {
15515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15516 }
15517 arg3 = static_cast< int >(val3);
15518 }
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15526 {
15527 if (temp1)
15528 delete arg1;
15529 }
15530 return resultobj;
15531 fail:
15532 {
15533 if (temp1)
15534 delete arg1;
15535 }
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15541 PyObject *resultobj = 0;
15542 wxImage *arg1 = (wxImage *) 0 ;
15543 void *argp1 = 0 ;
15544 int res1 = 0 ;
15545 PyObject *swig_obj[1] ;
15546
15547 if (!args) SWIG_fail;
15548 swig_obj[0] = args;
15549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15552 }
15553 arg1 = reinterpret_cast< wxImage * >(argp1);
15554 {
15555 PyThreadState* __tstate = wxPyBeginAllowThreads();
15556 delete arg1;
15557
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 resultobj = SWIG_Py_Void();
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15569 PyObject *resultobj = 0;
15570 wxString *arg1 = 0 ;
15571 wxString *arg2 = 0 ;
15572 int arg3 = (int) -1 ;
15573 wxImage *result = 0 ;
15574 bool temp1 = false ;
15575 bool temp2 = false ;
15576 int val3 ;
15577 int ecode3 = 0 ;
15578 PyObject * obj0 = 0 ;
15579 PyObject * obj1 = 0 ;
15580 PyObject * obj2 = 0 ;
15581 char * kwnames[] = {
15582 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15583 };
15584
15585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15586 {
15587 arg1 = wxString_in_helper(obj0);
15588 if (arg1 == NULL) SWIG_fail;
15589 temp1 = true;
15590 }
15591 {
15592 arg2 = wxString_in_helper(obj1);
15593 if (arg2 == NULL) SWIG_fail;
15594 temp2 = true;
15595 }
15596 if (obj2) {
15597 ecode3 = SWIG_AsVal_int(obj2, &val3);
15598 if (!SWIG_IsOK(ecode3)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15600 }
15601 arg3 = static_cast< int >(val3);
15602 }
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15610 {
15611 if (temp1)
15612 delete arg1;
15613 }
15614 {
15615 if (temp2)
15616 delete arg2;
15617 }
15618 return resultobj;
15619 fail:
15620 {
15621 if (temp1)
15622 delete arg1;
15623 }
15624 {
15625 if (temp2)
15626 delete arg2;
15627 }
15628 return NULL;
15629 }
15630
15631
15632 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj = 0;
15634 wxInputStream *arg1 = 0 ;
15635 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15636 int arg3 = (int) -1 ;
15637 wxImage *result = 0 ;
15638 wxPyInputStream *temp1 ;
15639 bool created1 ;
15640 long val2 ;
15641 int ecode2 = 0 ;
15642 int val3 ;
15643 int ecode3 = 0 ;
15644 PyObject * obj0 = 0 ;
15645 PyObject * obj1 = 0 ;
15646 PyObject * obj2 = 0 ;
15647 char * kwnames[] = {
15648 (char *) "stream",(char *) "type",(char *) "index", NULL
15649 };
15650
15651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15652 {
15653 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15654 arg1 = temp1->m_wxis;
15655 created1 = false;
15656 } else {
15657 PyErr_Clear(); // clear the failure of the wxPyConvert above
15658 arg1 = wxPyCBInputStream_create(obj0, false);
15659 if (arg1 == NULL) {
15660 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15661 SWIG_fail;
15662 }
15663 created1 = true;
15664 }
15665 }
15666 if (obj1) {
15667 ecode2 = SWIG_AsVal_long(obj1, &val2);
15668 if (!SWIG_IsOK(ecode2)) {
15669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15670 }
15671 arg2 = static_cast< long >(val2);
15672 }
15673 if (obj2) {
15674 ecode3 = SWIG_AsVal_int(obj2, &val3);
15675 if (!SWIG_IsOK(ecode3)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15677 }
15678 arg3 = static_cast< int >(val3);
15679 }
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15687 {
15688 if (created1) delete arg1;
15689 }
15690 return resultobj;
15691 fail:
15692 {
15693 if (created1) delete arg1;
15694 }
15695 return NULL;
15696 }
15697
15698
15699 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15700 PyObject *resultobj = 0;
15701 wxInputStream *arg1 = 0 ;
15702 wxString *arg2 = 0 ;
15703 int arg3 = (int) -1 ;
15704 wxImage *result = 0 ;
15705 wxPyInputStream *temp1 ;
15706 bool created1 ;
15707 bool temp2 = false ;
15708 int val3 ;
15709 int ecode3 = 0 ;
15710 PyObject * obj0 = 0 ;
15711 PyObject * obj1 = 0 ;
15712 PyObject * obj2 = 0 ;
15713 char * kwnames[] = {
15714 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15715 };
15716
15717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15718 {
15719 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15720 arg1 = temp1->m_wxis;
15721 created1 = false;
15722 } else {
15723 PyErr_Clear(); // clear the failure of the wxPyConvert above
15724 arg1 = wxPyCBInputStream_create(obj0, false);
15725 if (arg1 == NULL) {
15726 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15727 SWIG_fail;
15728 }
15729 created1 = true;
15730 }
15731 }
15732 {
15733 arg2 = wxString_in_helper(obj1);
15734 if (arg2 == NULL) SWIG_fail;
15735 temp2 = true;
15736 }
15737 if (obj2) {
15738 ecode3 = SWIG_AsVal_int(obj2, &val3);
15739 if (!SWIG_IsOK(ecode3)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15741 }
15742 arg3 = static_cast< int >(val3);
15743 }
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15751 {
15752 if (created1) delete arg1;
15753 }
15754 {
15755 if (temp2)
15756 delete arg2;
15757 }
15758 return resultobj;
15759 fail:
15760 {
15761 if (created1) delete arg1;
15762 }
15763 {
15764 if (temp2)
15765 delete arg2;
15766 }
15767 return NULL;
15768 }
15769
15770
15771 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15772 PyObject *resultobj = 0;
15773 int arg1 = (int) 0 ;
15774 int arg2 = (int) 0 ;
15775 bool arg3 = (bool) true ;
15776 wxImage *result = 0 ;
15777 int val1 ;
15778 int ecode1 = 0 ;
15779 int val2 ;
15780 int ecode2 = 0 ;
15781 bool val3 ;
15782 int ecode3 = 0 ;
15783 PyObject * obj0 = 0 ;
15784 PyObject * obj1 = 0 ;
15785 PyObject * obj2 = 0 ;
15786 char * kwnames[] = {
15787 (char *) "width",(char *) "height",(char *) "clear", NULL
15788 };
15789
15790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15791 if (obj0) {
15792 ecode1 = SWIG_AsVal_int(obj0, &val1);
15793 if (!SWIG_IsOK(ecode1)) {
15794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15795 }
15796 arg1 = static_cast< int >(val1);
15797 }
15798 if (obj1) {
15799 ecode2 = SWIG_AsVal_int(obj1, &val2);
15800 if (!SWIG_IsOK(ecode2)) {
15801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15802 }
15803 arg2 = static_cast< int >(val2);
15804 }
15805 if (obj2) {
15806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15807 if (!SWIG_IsOK(ecode3)) {
15808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15809 }
15810 arg3 = static_cast< bool >(val3);
15811 }
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15819 return resultobj;
15820 fail:
15821 return NULL;
15822 }
15823
15824
15825 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15826 PyObject *resultobj = 0;
15827 wxBitmap *arg1 = 0 ;
15828 wxImage *result = 0 ;
15829 void *argp1 = 0 ;
15830 int res1 = 0 ;
15831 PyObject * obj0 = 0 ;
15832 char * kwnames[] = {
15833 (char *) "bitmap", NULL
15834 };
15835
15836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15837 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15838 if (!SWIG_IsOK(res1)) {
15839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15840 }
15841 if (!argp1) {
15842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15843 }
15844 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15845 {
15846 if (!wxPyCheckForApp()) SWIG_fail;
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 int arg1 ;
15862 int arg2 ;
15863 buffer arg3 ;
15864 int arg4 ;
15865 wxImage *result = 0 ;
15866 int val1 ;
15867 int ecode1 = 0 ;
15868 int val2 ;
15869 int ecode2 = 0 ;
15870 Py_ssize_t temp3 ;
15871 PyObject * obj0 = 0 ;
15872 PyObject * obj1 = 0 ;
15873 PyObject * obj2 = 0 ;
15874 char * kwnames[] = {
15875 (char *) "width",(char *) "height",(char *) "data", NULL
15876 };
15877
15878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15879 ecode1 = SWIG_AsVal_int(obj0, &val1);
15880 if (!SWIG_IsOK(ecode1)) {
15881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15882 }
15883 arg1 = static_cast< int >(val1);
15884 ecode2 = SWIG_AsVal_int(obj1, &val2);
15885 if (!SWIG_IsOK(ecode2)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15887 }
15888 arg2 = static_cast< int >(val2);
15889 {
15890 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15891 arg4 = (int)temp3;
15892 }
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15907 PyObject *resultobj = 0;
15908 int arg1 ;
15909 int arg2 ;
15910 buffer arg3 ;
15911 int arg4 ;
15912 buffer arg5 ;
15913 int arg6 ;
15914 wxImage *result = 0 ;
15915 int val1 ;
15916 int ecode1 = 0 ;
15917 int val2 ;
15918 int ecode2 = 0 ;
15919 Py_ssize_t temp3 ;
15920 Py_ssize_t temp5 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 PyObject * obj2 = 0 ;
15924 PyObject * obj3 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15930 ecode1 = SWIG_AsVal_int(obj0, &val1);
15931 if (!SWIG_IsOK(ecode1)) {
15932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15933 }
15934 arg1 = static_cast< int >(val1);
15935 ecode2 = SWIG_AsVal_int(obj1, &val2);
15936 if (!SWIG_IsOK(ecode2)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15938 }
15939 arg2 = static_cast< int >(val2);
15940 {
15941 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15942 arg4 = (int)temp3;
15943 }
15944 {
15945 if (obj3 != Py_None) {
15946 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15947 arg6 = (int)temp5;
15948 }
15949 }
15950 {
15951 PyThreadState* __tstate = wxPyBeginAllowThreads();
15952 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj = 0;
15965 wxImage *arg1 = (wxImage *) 0 ;
15966 int arg2 ;
15967 int arg3 ;
15968 bool arg4 = (bool) true ;
15969 void *argp1 = 0 ;
15970 int res1 = 0 ;
15971 int val2 ;
15972 int ecode2 = 0 ;
15973 int val3 ;
15974 int ecode3 = 0 ;
15975 bool val4 ;
15976 int ecode4 = 0 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 PyObject * obj2 = 0 ;
15980 PyObject * obj3 = 0 ;
15981 char * kwnames[] = {
15982 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15983 };
15984
15985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15987 if (!SWIG_IsOK(res1)) {
15988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15989 }
15990 arg1 = reinterpret_cast< wxImage * >(argp1);
15991 ecode2 = SWIG_AsVal_int(obj1, &val2);
15992 if (!SWIG_IsOK(ecode2)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15994 }
15995 arg2 = static_cast< int >(val2);
15996 ecode3 = SWIG_AsVal_int(obj2, &val3);
15997 if (!SWIG_IsOK(ecode3)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15999 }
16000 arg3 = static_cast< int >(val3);
16001 if (obj3) {
16002 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16003 if (!SWIG_IsOK(ecode4)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16005 }
16006 arg4 = static_cast< bool >(val4);
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->Create(arg2,arg3,arg4);
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_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16022 PyObject *resultobj = 0;
16023 wxImage *arg1 = (wxImage *) 0 ;
16024 void *argp1 = 0 ;
16025 int res1 = 0 ;
16026 PyObject *swig_obj[1] ;
16027
16028 if (!args) SWIG_fail;
16029 swig_obj[0] = args;
16030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16031 if (!SWIG_IsOK(res1)) {
16032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16033 }
16034 arg1 = reinterpret_cast< wxImage * >(argp1);
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 (arg1)->Destroy();
16038 wxPyEndAllowThreads(__tstate);
16039 if (PyErr_Occurred()) SWIG_fail;
16040 }
16041 resultobj = SWIG_Py_Void();
16042 return resultobj;
16043 fail:
16044 return NULL;
16045 }
16046
16047
16048 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16049 PyObject *resultobj = 0;
16050 wxImage *arg1 = (wxImage *) 0 ;
16051 int arg2 ;
16052 int arg3 ;
16053 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16054 SwigValueWrapper<wxImage > result;
16055 void *argp1 = 0 ;
16056 int res1 = 0 ;
16057 int val2 ;
16058 int ecode2 = 0 ;
16059 int val3 ;
16060 int ecode3 = 0 ;
16061 int val4 ;
16062 int ecode4 = 0 ;
16063 PyObject * obj0 = 0 ;
16064 PyObject * obj1 = 0 ;
16065 PyObject * obj2 = 0 ;
16066 PyObject * obj3 = 0 ;
16067 char * kwnames[] = {
16068 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16069 };
16070
16071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16073 if (!SWIG_IsOK(res1)) {
16074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16075 }
16076 arg1 = reinterpret_cast< wxImage * >(argp1);
16077 ecode2 = SWIG_AsVal_int(obj1, &val2);
16078 if (!SWIG_IsOK(ecode2)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16080 }
16081 arg2 = static_cast< int >(val2);
16082 ecode3 = SWIG_AsVal_int(obj2, &val3);
16083 if (!SWIG_IsOK(ecode3)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16085 }
16086 arg3 = static_cast< int >(val3);
16087 if (obj3) {
16088 ecode4 = SWIG_AsVal_int(obj3, &val4);
16089 if (!SWIG_IsOK(ecode4)) {
16090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16091 }
16092 arg4 = static_cast< int >(val4);
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = (arg1)->Scale(arg2,arg3,arg4);
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16101 return resultobj;
16102 fail:
16103 return NULL;
16104 }
16105
16106
16107 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj = 0;
16109 wxImage *arg1 = (wxImage *) 0 ;
16110 int arg2 ;
16111 int arg3 ;
16112 SwigValueWrapper<wxImage > result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 int val2 ;
16116 int ecode2 = 0 ;
16117 int val3 ;
16118 int ecode3 = 0 ;
16119 PyObject * obj0 = 0 ;
16120 PyObject * obj1 = 0 ;
16121 PyObject * obj2 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "width",(char *) "height", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 ecode2 = SWIG_AsVal_int(obj1, &val2);
16133 if (!SWIG_IsOK(ecode2)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16135 }
16136 arg2 = static_cast< int >(val2);
16137 ecode3 = SWIG_AsVal_int(obj2, &val3);
16138 if (!SWIG_IsOK(ecode3)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16140 }
16141 arg3 = static_cast< int >(val3);
16142 {
16143 PyThreadState* __tstate = wxPyBeginAllowThreads();
16144 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16149 return resultobj;
16150 fail:
16151 return NULL;
16152 }
16153
16154
16155 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16156 PyObject *resultobj = 0;
16157 wxImage *arg1 = (wxImage *) 0 ;
16158 int arg2 ;
16159 int arg3 ;
16160 SwigValueWrapper<wxImage > result;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 int val2 ;
16164 int ecode2 = 0 ;
16165 int val3 ;
16166 int ecode3 = 0 ;
16167 PyObject * obj0 = 0 ;
16168 PyObject * obj1 = 0 ;
16169 PyObject * obj2 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "width",(char *) "height", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 ecode2 = SWIG_AsVal_int(obj1, &val2);
16181 if (!SWIG_IsOK(ecode2)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16183 }
16184 arg2 = static_cast< int >(val2);
16185 ecode3 = SWIG_AsVal_int(obj2, &val3);
16186 if (!SWIG_IsOK(ecode3)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16188 }
16189 arg3 = static_cast< int >(val3);
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16193 wxPyEndAllowThreads(__tstate);
16194 if (PyErr_Occurred()) SWIG_fail;
16195 }
16196 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16197 return resultobj;
16198 fail:
16199 return NULL;
16200 }
16201
16202
16203 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16204 PyObject *resultobj = 0;
16205 wxImage *arg1 = (wxImage *) 0 ;
16206 int arg2 ;
16207 SwigValueWrapper<wxImage > result;
16208 void *argp1 = 0 ;
16209 int res1 = 0 ;
16210 int val2 ;
16211 int ecode2 = 0 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 char * kwnames[] = {
16215 (char *) "self",(char *) "radius", NULL
16216 };
16217
16218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16222 }
16223 arg1 = reinterpret_cast< wxImage * >(argp1);
16224 ecode2 = SWIG_AsVal_int(obj1, &val2);
16225 if (!SWIG_IsOK(ecode2)) {
16226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16227 }
16228 arg2 = static_cast< int >(val2);
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 result = (arg1)->Blur(arg2);
16232 wxPyEndAllowThreads(__tstate);
16233 if (PyErr_Occurred()) SWIG_fail;
16234 }
16235 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16236 return resultobj;
16237 fail:
16238 return NULL;
16239 }
16240
16241
16242 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj = 0;
16244 wxImage *arg1 = (wxImage *) 0 ;
16245 int arg2 ;
16246 SwigValueWrapper<wxImage > result;
16247 void *argp1 = 0 ;
16248 int res1 = 0 ;
16249 int val2 ;
16250 int ecode2 = 0 ;
16251 PyObject * obj0 = 0 ;
16252 PyObject * obj1 = 0 ;
16253 char * kwnames[] = {
16254 (char *) "self",(char *) "radius", NULL
16255 };
16256
16257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16259 if (!SWIG_IsOK(res1)) {
16260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16261 }
16262 arg1 = reinterpret_cast< wxImage * >(argp1);
16263 ecode2 = SWIG_AsVal_int(obj1, &val2);
16264 if (!SWIG_IsOK(ecode2)) {
16265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16266 }
16267 arg2 = static_cast< int >(val2);
16268 {
16269 PyThreadState* __tstate = wxPyBeginAllowThreads();
16270 result = (arg1)->BlurHorizontal(arg2);
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj = 0;
16283 wxImage *arg1 = (wxImage *) 0 ;
16284 int arg2 ;
16285 SwigValueWrapper<wxImage > result;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 int val2 ;
16289 int ecode2 = 0 ;
16290 PyObject * obj0 = 0 ;
16291 PyObject * obj1 = 0 ;
16292 char * kwnames[] = {
16293 (char *) "self",(char *) "radius", NULL
16294 };
16295
16296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16298 if (!SWIG_IsOK(res1)) {
16299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16300 }
16301 arg1 = reinterpret_cast< wxImage * >(argp1);
16302 ecode2 = SWIG_AsVal_int(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16305 }
16306 arg2 = static_cast< int >(val2);
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = (arg1)->BlurVertical(arg2);
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj = 0;
16322 wxImage *arg1 = (wxImage *) 0 ;
16323 int arg2 ;
16324 int arg3 ;
16325 SwigValueWrapper<wxImage > result;
16326 void *argp1 = 0 ;
16327 int res1 = 0 ;
16328 int val2 ;
16329 int ecode2 = 0 ;
16330 int val3 ;
16331 int ecode3 = 0 ;
16332 PyObject * obj0 = 0 ;
16333 PyObject * obj1 = 0 ;
16334 PyObject * obj2 = 0 ;
16335 char * kwnames[] = {
16336 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16337 };
16338
16339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16341 if (!SWIG_IsOK(res1)) {
16342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16343 }
16344 arg1 = reinterpret_cast< wxImage * >(argp1);
16345 ecode2 = SWIG_AsVal_int(obj1, &val2);
16346 if (!SWIG_IsOK(ecode2)) {
16347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16348 }
16349 arg2 = static_cast< int >(val2);
16350 ecode3 = SWIG_AsVal_int(obj2, &val3);
16351 if (!SWIG_IsOK(ecode3)) {
16352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16353 }
16354 arg3 = static_cast< int >(val3);
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16362 return resultobj;
16363 fail:
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 wxImage *arg1 = (wxImage *) 0 ;
16371 int arg2 ;
16372 int arg3 ;
16373 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16374 wxImage *result = 0 ;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 int val2 ;
16378 int ecode2 = 0 ;
16379 int val3 ;
16380 int ecode3 = 0 ;
16381 int val4 ;
16382 int ecode4 = 0 ;
16383 PyObject * obj0 = 0 ;
16384 PyObject * obj1 = 0 ;
16385 PyObject * obj2 = 0 ;
16386 PyObject * obj3 = 0 ;
16387 char * kwnames[] = {
16388 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16389 };
16390
16391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16393 if (!SWIG_IsOK(res1)) {
16394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16395 }
16396 arg1 = reinterpret_cast< wxImage * >(argp1);
16397 ecode2 = SWIG_AsVal_int(obj1, &val2);
16398 if (!SWIG_IsOK(ecode2)) {
16399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16400 }
16401 arg2 = static_cast< int >(val2);
16402 ecode3 = SWIG_AsVal_int(obj2, &val3);
16403 if (!SWIG_IsOK(ecode3)) {
16404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16405 }
16406 arg3 = static_cast< int >(val3);
16407 if (obj3) {
16408 ecode4 = SWIG_AsVal_int(obj3, &val4);
16409 if (!SWIG_IsOK(ecode4)) {
16410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16411 }
16412 arg4 = static_cast< int >(val4);
16413 }
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 {
16417 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16418 result = (wxImage *) &_result_ref;
16419 }
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16431 PyObject *resultobj = 0;
16432 wxImage *arg1 = (wxImage *) 0 ;
16433 wxSize *arg2 = 0 ;
16434 wxPoint *arg3 = 0 ;
16435 int arg4 = (int) -1 ;
16436 int arg5 = (int) -1 ;
16437 int arg6 = (int) -1 ;
16438 wxImage *result = 0 ;
16439 void *argp1 = 0 ;
16440 int res1 = 0 ;
16441 wxSize temp2 ;
16442 wxPoint temp3 ;
16443 int val4 ;
16444 int ecode4 = 0 ;
16445 int val5 ;
16446 int ecode5 = 0 ;
16447 int val6 ;
16448 int ecode6 = 0 ;
16449 PyObject * obj0 = 0 ;
16450 PyObject * obj1 = 0 ;
16451 PyObject * obj2 = 0 ;
16452 PyObject * obj3 = 0 ;
16453 PyObject * obj4 = 0 ;
16454 PyObject * obj5 = 0 ;
16455 char * kwnames[] = {
16456 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16457 };
16458
16459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16463 }
16464 arg1 = reinterpret_cast< wxImage * >(argp1);
16465 {
16466 arg2 = &temp2;
16467 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16468 }
16469 {
16470 arg3 = &temp3;
16471 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16472 }
16473 if (obj3) {
16474 ecode4 = SWIG_AsVal_int(obj3, &val4);
16475 if (!SWIG_IsOK(ecode4)) {
16476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16477 }
16478 arg4 = static_cast< int >(val4);
16479 }
16480 if (obj4) {
16481 ecode5 = SWIG_AsVal_int(obj4, &val5);
16482 if (!SWIG_IsOK(ecode5)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16484 }
16485 arg5 = static_cast< int >(val5);
16486 }
16487 if (obj5) {
16488 ecode6 = SWIG_AsVal_int(obj5, &val6);
16489 if (!SWIG_IsOK(ecode6)) {
16490 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16491 }
16492 arg6 = static_cast< int >(val6);
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 {
16497 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16498 result = (wxImage *) &_result_ref;
16499 }
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 int arg2 ;
16514 int arg3 ;
16515 byte arg4 ;
16516 byte arg5 ;
16517 byte arg6 ;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 int val2 ;
16521 int ecode2 = 0 ;
16522 int val3 ;
16523 int ecode3 = 0 ;
16524 unsigned char val4 ;
16525 int ecode4 = 0 ;
16526 unsigned char val5 ;
16527 int ecode5 = 0 ;
16528 unsigned char val6 ;
16529 int ecode6 = 0 ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 PyObject * obj2 = 0 ;
16533 PyObject * obj3 = 0 ;
16534 PyObject * obj4 = 0 ;
16535 PyObject * obj5 = 0 ;
16536 char * kwnames[] = {
16537 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16538 };
16539
16540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16542 if (!SWIG_IsOK(res1)) {
16543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16544 }
16545 arg1 = reinterpret_cast< wxImage * >(argp1);
16546 ecode2 = SWIG_AsVal_int(obj1, &val2);
16547 if (!SWIG_IsOK(ecode2)) {
16548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16549 }
16550 arg2 = static_cast< int >(val2);
16551 ecode3 = SWIG_AsVal_int(obj2, &val3);
16552 if (!SWIG_IsOK(ecode3)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16554 }
16555 arg3 = static_cast< int >(val3);
16556 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16557 if (!SWIG_IsOK(ecode4)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16559 }
16560 arg4 = static_cast< byte >(val4);
16561 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16562 if (!SWIG_IsOK(ecode5)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16564 }
16565 arg5 = static_cast< byte >(val5);
16566 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16567 if (!SWIG_IsOK(ecode6)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16569 }
16570 arg6 = static_cast< byte >(val6);
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 resultobj = SWIG_Py_Void();
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj = 0;
16586 wxImage *arg1 = (wxImage *) 0 ;
16587 wxRect *arg2 = 0 ;
16588 byte arg3 ;
16589 byte arg4 ;
16590 byte arg5 ;
16591 void *argp1 = 0 ;
16592 int res1 = 0 ;
16593 wxRect temp2 ;
16594 unsigned char val3 ;
16595 int ecode3 = 0 ;
16596 unsigned char val4 ;
16597 int ecode4 = 0 ;
16598 unsigned char val5 ;
16599 int ecode5 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 PyObject * obj1 = 0 ;
16602 PyObject * obj2 = 0 ;
16603 PyObject * obj3 = 0 ;
16604 PyObject * obj4 = 0 ;
16605 char * kwnames[] = {
16606 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16607 };
16608
16609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16611 if (!SWIG_IsOK(res1)) {
16612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16613 }
16614 arg1 = reinterpret_cast< wxImage * >(argp1);
16615 {
16616 arg2 = &temp2;
16617 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16618 }
16619 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16620 if (!SWIG_IsOK(ecode3)) {
16621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16622 }
16623 arg3 = static_cast< byte >(val3);
16624 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16625 if (!SWIG_IsOK(ecode4)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16627 }
16628 arg4 = static_cast< byte >(val4);
16629 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16630 if (!SWIG_IsOK(ecode5)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16632 }
16633 arg5 = static_cast< byte >(val5);
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_Py_Void();
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxImage *arg1 = (wxImage *) 0 ;
16650 int arg2 ;
16651 int arg3 ;
16652 byte result;
16653 void *argp1 = 0 ;
16654 int res1 = 0 ;
16655 int val2 ;
16656 int ecode2 = 0 ;
16657 int val3 ;
16658 int ecode3 = 0 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 PyObject * obj2 = 0 ;
16662 char * kwnames[] = {
16663 (char *) "self",(char *) "x",(char *) "y", NULL
16664 };
16665
16666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16670 }
16671 arg1 = reinterpret_cast< wxImage * >(argp1);
16672 ecode2 = SWIG_AsVal_int(obj1, &val2);
16673 if (!SWIG_IsOK(ecode2)) {
16674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16675 }
16676 arg2 = static_cast< int >(val2);
16677 ecode3 = SWIG_AsVal_int(obj2, &val3);
16678 if (!SWIG_IsOK(ecode3)) {
16679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16680 }
16681 arg3 = static_cast< int >(val3);
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = (byte)(arg1)->GetRed(arg2,arg3);
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16696 PyObject *resultobj = 0;
16697 wxImage *arg1 = (wxImage *) 0 ;
16698 int arg2 ;
16699 int arg3 ;
16700 byte result;
16701 void *argp1 = 0 ;
16702 int res1 = 0 ;
16703 int val2 ;
16704 int ecode2 = 0 ;
16705 int val3 ;
16706 int ecode3 = 0 ;
16707 PyObject * obj0 = 0 ;
16708 PyObject * obj1 = 0 ;
16709 PyObject * obj2 = 0 ;
16710 char * kwnames[] = {
16711 (char *) "self",(char *) "x",(char *) "y", NULL
16712 };
16713
16714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16716 if (!SWIG_IsOK(res1)) {
16717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16718 }
16719 arg1 = reinterpret_cast< wxImage * >(argp1);
16720 ecode2 = SWIG_AsVal_int(obj1, &val2);
16721 if (!SWIG_IsOK(ecode2)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16723 }
16724 arg2 = static_cast< int >(val2);
16725 ecode3 = SWIG_AsVal_int(obj2, &val3);
16726 if (!SWIG_IsOK(ecode3)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16728 }
16729 arg3 = static_cast< int >(val3);
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = (byte)(arg1)->GetGreen(arg2,arg3);
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj = 0;
16745 wxImage *arg1 = (wxImage *) 0 ;
16746 int arg2 ;
16747 int arg3 ;
16748 byte result;
16749 void *argp1 = 0 ;
16750 int res1 = 0 ;
16751 int val2 ;
16752 int ecode2 = 0 ;
16753 int val3 ;
16754 int ecode3 = 0 ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 PyObject * obj2 = 0 ;
16758 char * kwnames[] = {
16759 (char *) "self",(char *) "x",(char *) "y", NULL
16760 };
16761
16762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16764 if (!SWIG_IsOK(res1)) {
16765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16766 }
16767 arg1 = reinterpret_cast< wxImage * >(argp1);
16768 ecode2 = SWIG_AsVal_int(obj1, &val2);
16769 if (!SWIG_IsOK(ecode2)) {
16770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16771 }
16772 arg2 = static_cast< int >(val2);
16773 ecode3 = SWIG_AsVal_int(obj2, &val3);
16774 if (!SWIG_IsOK(ecode3)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16776 }
16777 arg3 = static_cast< int >(val3);
16778 {
16779 PyThreadState* __tstate = wxPyBeginAllowThreads();
16780 result = (byte)(arg1)->GetBlue(arg2,arg3);
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj = 0;
16793 wxImage *arg1 = (wxImage *) 0 ;
16794 int arg2 ;
16795 int arg3 ;
16796 byte arg4 ;
16797 void *argp1 = 0 ;
16798 int res1 = 0 ;
16799 int val2 ;
16800 int ecode2 = 0 ;
16801 int val3 ;
16802 int ecode3 = 0 ;
16803 unsigned char val4 ;
16804 int ecode4 = 0 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 PyObject * obj2 = 0 ;
16808 PyObject * obj3 = 0 ;
16809 char * kwnames[] = {
16810 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16811 };
16812
16813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16815 if (!SWIG_IsOK(res1)) {
16816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16817 }
16818 arg1 = reinterpret_cast< wxImage * >(argp1);
16819 ecode2 = SWIG_AsVal_int(obj1, &val2);
16820 if (!SWIG_IsOK(ecode2)) {
16821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16822 }
16823 arg2 = static_cast< int >(val2);
16824 ecode3 = SWIG_AsVal_int(obj2, &val3);
16825 if (!SWIG_IsOK(ecode3)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16827 }
16828 arg3 = static_cast< int >(val3);
16829 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16830 if (!SWIG_IsOK(ecode4)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16832 }
16833 arg4 = static_cast< byte >(val4);
16834 {
16835 PyThreadState* __tstate = wxPyBeginAllowThreads();
16836 (arg1)->SetAlpha(arg2,arg3,arg4);
16837 wxPyEndAllowThreads(__tstate);
16838 if (PyErr_Occurred()) SWIG_fail;
16839 }
16840 resultobj = SWIG_Py_Void();
16841 return resultobj;
16842 fail:
16843 return NULL;
16844 }
16845
16846
16847 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16848 PyObject *resultobj = 0;
16849 wxImage *arg1 = (wxImage *) 0 ;
16850 int arg2 ;
16851 int arg3 ;
16852 byte result;
16853 void *argp1 = 0 ;
16854 int res1 = 0 ;
16855 int val2 ;
16856 int ecode2 = 0 ;
16857 int val3 ;
16858 int ecode3 = 0 ;
16859 PyObject * obj0 = 0 ;
16860 PyObject * obj1 = 0 ;
16861 PyObject * obj2 = 0 ;
16862 char * kwnames[] = {
16863 (char *) "self",(char *) "x",(char *) "y", NULL
16864 };
16865
16866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16868 if (!SWIG_IsOK(res1)) {
16869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16870 }
16871 arg1 = reinterpret_cast< wxImage * >(argp1);
16872 ecode2 = SWIG_AsVal_int(obj1, &val2);
16873 if (!SWIG_IsOK(ecode2)) {
16874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16875 }
16876 arg2 = static_cast< int >(val2);
16877 ecode3 = SWIG_AsVal_int(obj2, &val3);
16878 if (!SWIG_IsOK(ecode3)) {
16879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16880 }
16881 arg3 = static_cast< int >(val3);
16882 {
16883 PyThreadState* __tstate = wxPyBeginAllowThreads();
16884 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16896 PyObject *resultobj = 0;
16897 wxImage *arg1 = (wxImage *) 0 ;
16898 bool result;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 PyObject *swig_obj[1] ;
16902
16903 if (!args) SWIG_fail;
16904 swig_obj[0] = args;
16905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16908 }
16909 arg1 = reinterpret_cast< wxImage * >(argp1);
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 result = (bool)(arg1)->HasAlpha();
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 {
16917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16918 }
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16926 PyObject *resultobj = 0;
16927 wxImage *arg1 = (wxImage *) 0 ;
16928 void *argp1 = 0 ;
16929 int res1 = 0 ;
16930 PyObject *swig_obj[1] ;
16931
16932 if (!args) SWIG_fail;
16933 swig_obj[0] = args;
16934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16935 if (!SWIG_IsOK(res1)) {
16936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16937 }
16938 arg1 = reinterpret_cast< wxImage * >(argp1);
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 (arg1)->InitAlpha();
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 resultobj = SWIG_Py_Void();
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj = 0;
16954 wxImage *arg1 = (wxImage *) 0 ;
16955 int arg2 ;
16956 int arg3 ;
16957 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16958 bool result;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 int val2 ;
16962 int ecode2 = 0 ;
16963 int val3 ;
16964 int ecode3 = 0 ;
16965 unsigned char val4 ;
16966 int ecode4 = 0 ;
16967 PyObject * obj0 = 0 ;
16968 PyObject * obj1 = 0 ;
16969 PyObject * obj2 = 0 ;
16970 PyObject * obj3 = 0 ;
16971 char * kwnames[] = {
16972 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16973 };
16974
16975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16977 if (!SWIG_IsOK(res1)) {
16978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16979 }
16980 arg1 = reinterpret_cast< wxImage * >(argp1);
16981 ecode2 = SWIG_AsVal_int(obj1, &val2);
16982 if (!SWIG_IsOK(ecode2)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16984 }
16985 arg2 = static_cast< int >(val2);
16986 ecode3 = SWIG_AsVal_int(obj2, &val3);
16987 if (!SWIG_IsOK(ecode3)) {
16988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16989 }
16990 arg3 = static_cast< int >(val3);
16991 if (obj3) {
16992 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16993 if (!SWIG_IsOK(ecode4)) {
16994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16995 }
16996 arg4 = static_cast< byte >(val4);
16997 }
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 {
17005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17006 }
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj = 0;
17015 wxImage *arg1 = (wxImage *) 0 ;
17016 byte *arg2 = (byte *) 0 ;
17017 byte *arg3 = (byte *) 0 ;
17018 byte *arg4 = (byte *) 0 ;
17019 byte arg5 = (byte) 0 ;
17020 byte arg6 = (byte) 0 ;
17021 byte arg7 = (byte) 0 ;
17022 bool result;
17023 void *argp1 = 0 ;
17024 int res1 = 0 ;
17025 byte temp2 ;
17026 int res2 = SWIG_TMPOBJ ;
17027 byte temp3 ;
17028 int res3 = SWIG_TMPOBJ ;
17029 byte temp4 ;
17030 int res4 = SWIG_TMPOBJ ;
17031 unsigned char val5 ;
17032 int ecode5 = 0 ;
17033 unsigned char val6 ;
17034 int ecode6 = 0 ;
17035 unsigned char val7 ;
17036 int ecode7 = 0 ;
17037 PyObject * obj0 = 0 ;
17038 PyObject * obj1 = 0 ;
17039 PyObject * obj2 = 0 ;
17040 PyObject * obj3 = 0 ;
17041 char * kwnames[] = {
17042 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17043 };
17044
17045 arg2 = &temp2;
17046 arg3 = &temp3;
17047 arg4 = &temp4;
17048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17050 if (!SWIG_IsOK(res1)) {
17051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17052 }
17053 arg1 = reinterpret_cast< wxImage * >(argp1);
17054 if (obj1) {
17055 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17056 if (!SWIG_IsOK(ecode5)) {
17057 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17058 }
17059 arg5 = static_cast< byte >(val5);
17060 }
17061 if (obj2) {
17062 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17063 if (!SWIG_IsOK(ecode6)) {
17064 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17065 }
17066 arg6 = static_cast< byte >(val6);
17067 }
17068 if (obj3) {
17069 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17070 if (!SWIG_IsOK(ecode7)) {
17071 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17072 }
17073 arg7 = static_cast< byte >(val7);
17074 }
17075 {
17076 PyThreadState* __tstate = wxPyBeginAllowThreads();
17077 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17078 wxPyEndAllowThreads(__tstate);
17079 if (PyErr_Occurred()) SWIG_fail;
17080 }
17081 {
17082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17083 }
17084 if (SWIG_IsTmpObj(res2)) {
17085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17086 } else {
17087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17089 }
17090 if (SWIG_IsTmpObj(res3)) {
17091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17092 } else {
17093 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17095 }
17096 if (SWIG_IsTmpObj(res4)) {
17097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17098 } else {
17099 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj = 0;
17110 wxImage *arg1 = (wxImage *) 0 ;
17111 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17112 bool result;
17113 void *argp1 = 0 ;
17114 int res1 = 0 ;
17115 unsigned char val2 ;
17116 int ecode2 = 0 ;
17117 PyObject * obj0 = 0 ;
17118 PyObject * obj1 = 0 ;
17119 char * kwnames[] = {
17120 (char *) "self",(char *) "threshold", NULL
17121 };
17122
17123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17125 if (!SWIG_IsOK(res1)) {
17126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17127 }
17128 arg1 = reinterpret_cast< wxImage * >(argp1);
17129 if (obj1) {
17130 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17131 if (!SWIG_IsOK(ecode2)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17133 }
17134 arg2 = static_cast< byte >(val2);
17135 }
17136 {
17137 PyThreadState* __tstate = wxPyBeginAllowThreads();
17138 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17139 wxPyEndAllowThreads(__tstate);
17140 if (PyErr_Occurred()) SWIG_fail;
17141 }
17142 {
17143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17144 }
17145 return resultobj;
17146 fail:
17147 return NULL;
17148 }
17149
17150
17151 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17152 PyObject *resultobj = 0;
17153 wxImage *arg1 = (wxImage *) 0 ;
17154 byte arg2 ;
17155 byte arg3 ;
17156 byte arg4 ;
17157 bool result;
17158 void *argp1 = 0 ;
17159 int res1 = 0 ;
17160 unsigned char val2 ;
17161 int ecode2 = 0 ;
17162 unsigned char val3 ;
17163 int ecode3 = 0 ;
17164 unsigned char val4 ;
17165 int ecode4 = 0 ;
17166 PyObject * obj0 = 0 ;
17167 PyObject * obj1 = 0 ;
17168 PyObject * obj2 = 0 ;
17169 PyObject * obj3 = 0 ;
17170 char * kwnames[] = {
17171 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17172 };
17173
17174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17176 if (!SWIG_IsOK(res1)) {
17177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17178 }
17179 arg1 = reinterpret_cast< wxImage * >(argp1);
17180 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17181 if (!SWIG_IsOK(ecode2)) {
17182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17183 }
17184 arg2 = static_cast< byte >(val2);
17185 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17186 if (!SWIG_IsOK(ecode3)) {
17187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17188 }
17189 arg3 = static_cast< byte >(val3);
17190 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17191 if (!SWIG_IsOK(ecode4)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17193 }
17194 arg4 = static_cast< byte >(val4);
17195 {
17196 PyThreadState* __tstate = wxPyBeginAllowThreads();
17197 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj = 0;
17212 wxImage *arg1 = (wxImage *) 0 ;
17213 wxImage *arg2 = 0 ;
17214 byte arg3 ;
17215 byte arg4 ;
17216 byte arg5 ;
17217 bool result;
17218 void *argp1 = 0 ;
17219 int res1 = 0 ;
17220 void *argp2 = 0 ;
17221 int res2 = 0 ;
17222 unsigned char val3 ;
17223 int ecode3 = 0 ;
17224 unsigned char val4 ;
17225 int ecode4 = 0 ;
17226 unsigned char val5 ;
17227 int ecode5 = 0 ;
17228 PyObject * obj0 = 0 ;
17229 PyObject * obj1 = 0 ;
17230 PyObject * obj2 = 0 ;
17231 PyObject * obj3 = 0 ;
17232 PyObject * obj4 = 0 ;
17233 char * kwnames[] = {
17234 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17235 };
17236
17237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17239 if (!SWIG_IsOK(res1)) {
17240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17241 }
17242 arg1 = reinterpret_cast< wxImage * >(argp1);
17243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17244 if (!SWIG_IsOK(res2)) {
17245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17246 }
17247 if (!argp2) {
17248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17249 }
17250 arg2 = reinterpret_cast< wxImage * >(argp2);
17251 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17252 if (!SWIG_IsOK(ecode3)) {
17253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17254 }
17255 arg3 = static_cast< byte >(val3);
17256 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17257 if (!SWIG_IsOK(ecode4)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17259 }
17260 arg4 = static_cast< byte >(val4);
17261 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17262 if (!SWIG_IsOK(ecode5)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17264 }
17265 arg5 = static_cast< byte >(val5);
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 {
17273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17274 }
17275 return resultobj;
17276 fail:
17277 return NULL;
17278 }
17279
17280
17281 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj = 0;
17283 wxString *arg1 = 0 ;
17284 bool result;
17285 bool temp1 = false ;
17286 PyObject * obj0 = 0 ;
17287 char * kwnames[] = {
17288 (char *) "filename", NULL
17289 };
17290
17291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17292 {
17293 arg1 = wxString_in_helper(obj0);
17294 if (arg1 == NULL) SWIG_fail;
17295 temp1 = true;
17296 }
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 {
17304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17305 }
17306 {
17307 if (temp1)
17308 delete arg1;
17309 }
17310 return resultobj;
17311 fail:
17312 {
17313 if (temp1)
17314 delete arg1;
17315 }
17316 return NULL;
17317 }
17318
17319
17320 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17321 PyObject *resultobj = 0;
17322 wxString *arg1 = 0 ;
17323 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17324 int result;
17325 bool temp1 = false ;
17326 long val2 ;
17327 int ecode2 = 0 ;
17328 PyObject * obj0 = 0 ;
17329 PyObject * obj1 = 0 ;
17330 char * kwnames[] = {
17331 (char *) "filename",(char *) "type", NULL
17332 };
17333
17334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17335 {
17336 arg1 = wxString_in_helper(obj0);
17337 if (arg1 == NULL) SWIG_fail;
17338 temp1 = true;
17339 }
17340 if (obj1) {
17341 ecode2 = SWIG_AsVal_long(obj1, &val2);
17342 if (!SWIG_IsOK(ecode2)) {
17343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17344 }
17345 arg2 = static_cast< long >(val2);
17346 }
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17350 wxPyEndAllowThreads(__tstate);
17351 if (PyErr_Occurred()) SWIG_fail;
17352 }
17353 resultobj = SWIG_From_int(static_cast< int >(result));
17354 {
17355 if (temp1)
17356 delete arg1;
17357 }
17358 return resultobj;
17359 fail:
17360 {
17361 if (temp1)
17362 delete arg1;
17363 }
17364 return NULL;
17365 }
17366
17367
17368 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17369 PyObject *resultobj = 0;
17370 wxImage *arg1 = (wxImage *) 0 ;
17371 wxString *arg2 = 0 ;
17372 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17373 int arg4 = (int) -1 ;
17374 bool result;
17375 void *argp1 = 0 ;
17376 int res1 = 0 ;
17377 bool temp2 = false ;
17378 long val3 ;
17379 int ecode3 = 0 ;
17380 int val4 ;
17381 int ecode4 = 0 ;
17382 PyObject * obj0 = 0 ;
17383 PyObject * obj1 = 0 ;
17384 PyObject * obj2 = 0 ;
17385 PyObject * obj3 = 0 ;
17386 char * kwnames[] = {
17387 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17388 };
17389
17390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17392 if (!SWIG_IsOK(res1)) {
17393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17394 }
17395 arg1 = reinterpret_cast< wxImage * >(argp1);
17396 {
17397 arg2 = wxString_in_helper(obj1);
17398 if (arg2 == NULL) SWIG_fail;
17399 temp2 = true;
17400 }
17401 if (obj2) {
17402 ecode3 = SWIG_AsVal_long(obj2, &val3);
17403 if (!SWIG_IsOK(ecode3)) {
17404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17405 }
17406 arg3 = static_cast< long >(val3);
17407 }
17408 if (obj3) {
17409 ecode4 = SWIG_AsVal_int(obj3, &val4);
17410 if (!SWIG_IsOK(ecode4)) {
17411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17412 }
17413 arg4 = static_cast< int >(val4);
17414 }
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 {
17422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17423 }
17424 {
17425 if (temp2)
17426 delete arg2;
17427 }
17428 return resultobj;
17429 fail:
17430 {
17431 if (temp2)
17432 delete arg2;
17433 }
17434 return NULL;
17435 }
17436
17437
17438 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj = 0;
17440 wxImage *arg1 = (wxImage *) 0 ;
17441 wxString *arg2 = 0 ;
17442 wxString *arg3 = 0 ;
17443 int arg4 = (int) -1 ;
17444 bool result;
17445 void *argp1 = 0 ;
17446 int res1 = 0 ;
17447 bool temp2 = false ;
17448 bool temp3 = false ;
17449 int val4 ;
17450 int ecode4 = 0 ;
17451 PyObject * obj0 = 0 ;
17452 PyObject * obj1 = 0 ;
17453 PyObject * obj2 = 0 ;
17454 PyObject * obj3 = 0 ;
17455 char * kwnames[] = {
17456 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17457 };
17458
17459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17461 if (!SWIG_IsOK(res1)) {
17462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17463 }
17464 arg1 = reinterpret_cast< wxImage * >(argp1);
17465 {
17466 arg2 = wxString_in_helper(obj1);
17467 if (arg2 == NULL) SWIG_fail;
17468 temp2 = true;
17469 }
17470 {
17471 arg3 = wxString_in_helper(obj2);
17472 if (arg3 == NULL) SWIG_fail;
17473 temp3 = true;
17474 }
17475 if (obj3) {
17476 ecode4 = SWIG_AsVal_int(obj3, &val4);
17477 if (!SWIG_IsOK(ecode4)) {
17478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17479 }
17480 arg4 = static_cast< int >(val4);
17481 }
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 {
17489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17490 }
17491 {
17492 if (temp2)
17493 delete arg2;
17494 }
17495 {
17496 if (temp3)
17497 delete arg3;
17498 }
17499 return resultobj;
17500 fail:
17501 {
17502 if (temp2)
17503 delete arg2;
17504 }
17505 {
17506 if (temp3)
17507 delete arg3;
17508 }
17509 return NULL;
17510 }
17511
17512
17513 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj = 0;
17515 wxImage *arg1 = (wxImage *) 0 ;
17516 wxString *arg2 = 0 ;
17517 int arg3 ;
17518 bool result;
17519 void *argp1 = 0 ;
17520 int res1 = 0 ;
17521 bool temp2 = false ;
17522 int val3 ;
17523 int ecode3 = 0 ;
17524 PyObject * obj0 = 0 ;
17525 PyObject * obj1 = 0 ;
17526 PyObject * obj2 = 0 ;
17527 char * kwnames[] = {
17528 (char *) "self",(char *) "name",(char *) "type", NULL
17529 };
17530
17531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17533 if (!SWIG_IsOK(res1)) {
17534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17535 }
17536 arg1 = reinterpret_cast< wxImage * >(argp1);
17537 {
17538 arg2 = wxString_in_helper(obj1);
17539 if (arg2 == NULL) SWIG_fail;
17540 temp2 = true;
17541 }
17542 ecode3 = SWIG_AsVal_int(obj2, &val3);
17543 if (!SWIG_IsOK(ecode3)) {
17544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17545 }
17546 arg3 = static_cast< int >(val3);
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17555 }
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return resultobj;
17561 fail:
17562 {
17563 if (temp2)
17564 delete arg2;
17565 }
17566 return NULL;
17567 }
17568
17569
17570 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj = 0;
17572 wxImage *arg1 = (wxImage *) 0 ;
17573 wxString *arg2 = 0 ;
17574 wxString *arg3 = 0 ;
17575 bool result;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 bool temp2 = false ;
17579 bool temp3 = false ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 PyObject * obj2 = 0 ;
17583 char * kwnames[] = {
17584 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17585 };
17586
17587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17589 if (!SWIG_IsOK(res1)) {
17590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17591 }
17592 arg1 = reinterpret_cast< wxImage * >(argp1);
17593 {
17594 arg2 = wxString_in_helper(obj1);
17595 if (arg2 == NULL) SWIG_fail;
17596 temp2 = true;
17597 }
17598 {
17599 arg3 = wxString_in_helper(obj2);
17600 if (arg3 == NULL) SWIG_fail;
17601 temp3 = true;
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 {
17610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17611 }
17612 {
17613 if (temp2)
17614 delete arg2;
17615 }
17616 {
17617 if (temp3)
17618 delete arg3;
17619 }
17620 return resultobj;
17621 fail:
17622 {
17623 if (temp2)
17624 delete arg2;
17625 }
17626 {
17627 if (temp3)
17628 delete arg3;
17629 }
17630 return NULL;
17631 }
17632
17633
17634 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17635 PyObject *resultobj = 0;
17636 wxInputStream *arg1 = 0 ;
17637 bool result;
17638 wxPyInputStream *temp1 ;
17639 bool created1 ;
17640 PyObject * obj0 = 0 ;
17641 char * kwnames[] = {
17642 (char *) "stream", NULL
17643 };
17644
17645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17646 {
17647 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17648 arg1 = temp1->m_wxis;
17649 created1 = false;
17650 } else {
17651 PyErr_Clear(); // clear the failure of the wxPyConvert above
17652 arg1 = wxPyCBInputStream_create(obj0, false);
17653 if (arg1 == NULL) {
17654 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17655 SWIG_fail;
17656 }
17657 created1 = true;
17658 }
17659 }
17660 {
17661 PyThreadState* __tstate = wxPyBeginAllowThreads();
17662 result = (bool)wxImage::CanRead(*arg1);
17663 wxPyEndAllowThreads(__tstate);
17664 if (PyErr_Occurred()) SWIG_fail;
17665 }
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 {
17670 if (created1) delete arg1;
17671 }
17672 return resultobj;
17673 fail:
17674 {
17675 if (created1) delete arg1;
17676 }
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj = 0;
17683 wxImage *arg1 = (wxImage *) 0 ;
17684 wxInputStream *arg2 = 0 ;
17685 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17686 int arg4 = (int) -1 ;
17687 bool result;
17688 void *argp1 = 0 ;
17689 int res1 = 0 ;
17690 wxPyInputStream *temp2 ;
17691 bool created2 ;
17692 long val3 ;
17693 int ecode3 = 0 ;
17694 int val4 ;
17695 int ecode4 = 0 ;
17696 PyObject * obj0 = 0 ;
17697 PyObject * obj1 = 0 ;
17698 PyObject * obj2 = 0 ;
17699 PyObject * obj3 = 0 ;
17700 char * kwnames[] = {
17701 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17702 };
17703
17704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17706 if (!SWIG_IsOK(res1)) {
17707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17708 }
17709 arg1 = reinterpret_cast< wxImage * >(argp1);
17710 {
17711 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17712 arg2 = temp2->m_wxis;
17713 created2 = false;
17714 } else {
17715 PyErr_Clear(); // clear the failure of the wxPyConvert above
17716 arg2 = wxPyCBInputStream_create(obj1, false);
17717 if (arg2 == NULL) {
17718 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17719 SWIG_fail;
17720 }
17721 created2 = true;
17722 }
17723 }
17724 if (obj2) {
17725 ecode3 = SWIG_AsVal_long(obj2, &val3);
17726 if (!SWIG_IsOK(ecode3)) {
17727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17728 }
17729 arg3 = static_cast< long >(val3);
17730 }
17731 if (obj3) {
17732 ecode4 = SWIG_AsVal_int(obj3, &val4);
17733 if (!SWIG_IsOK(ecode4)) {
17734 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17735 }
17736 arg4 = static_cast< int >(val4);
17737 }
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 {
17745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17746 }
17747 {
17748 if (created2) delete arg2;
17749 }
17750 return resultobj;
17751 fail:
17752 {
17753 if (created2) delete arg2;
17754 }
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = 0;
17761 wxImage *arg1 = (wxImage *) 0 ;
17762 wxInputStream *arg2 = 0 ;
17763 wxString *arg3 = 0 ;
17764 int arg4 = (int) -1 ;
17765 bool result;
17766 void *argp1 = 0 ;
17767 int res1 = 0 ;
17768 wxPyInputStream *temp2 ;
17769 bool created2 ;
17770 bool temp3 = false ;
17771 int val4 ;
17772 int ecode4 = 0 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 PyObject * obj2 = 0 ;
17776 PyObject * obj3 = 0 ;
17777 char * kwnames[] = {
17778 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17779 };
17780
17781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17785 }
17786 arg1 = reinterpret_cast< wxImage * >(argp1);
17787 {
17788 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17789 arg2 = temp2->m_wxis;
17790 created2 = false;
17791 } else {
17792 PyErr_Clear(); // clear the failure of the wxPyConvert above
17793 arg2 = wxPyCBInputStream_create(obj1, false);
17794 if (arg2 == NULL) {
17795 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17796 SWIG_fail;
17797 }
17798 created2 = true;
17799 }
17800 }
17801 {
17802 arg3 = wxString_in_helper(obj2);
17803 if (arg3 == NULL) SWIG_fail;
17804 temp3 = true;
17805 }
17806 if (obj3) {
17807 ecode4 = SWIG_AsVal_int(obj3, &val4);
17808 if (!SWIG_IsOK(ecode4)) {
17809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17810 }
17811 arg4 = static_cast< int >(val4);
17812 }
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 {
17820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17821 }
17822 {
17823 if (created2) delete arg2;
17824 }
17825 {
17826 if (temp3)
17827 delete arg3;
17828 }
17829 return resultobj;
17830 fail:
17831 {
17832 if (created2) delete arg2;
17833 }
17834 {
17835 if (temp3)
17836 delete arg3;
17837 }
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxImage *arg1 = (wxImage *) 0 ;
17845 bool result;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17855 }
17856 arg1 = reinterpret_cast< wxImage * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)(arg1)->IsOk();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 {
17864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17873 PyObject *resultobj = 0;
17874 wxImage *arg1 = (wxImage *) 0 ;
17875 int result;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 PyObject *swig_obj[1] ;
17879
17880 if (!args) SWIG_fail;
17881 swig_obj[0] = args;
17882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17883 if (!SWIG_IsOK(res1)) {
17884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17885 }
17886 arg1 = reinterpret_cast< wxImage * >(argp1);
17887 {
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 result = (int)(arg1)->GetWidth();
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 resultobj = SWIG_From_int(static_cast< int >(result));
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17901 PyObject *resultobj = 0;
17902 wxImage *arg1 = (wxImage *) 0 ;
17903 int result;
17904 void *argp1 = 0 ;
17905 int res1 = 0 ;
17906 PyObject *swig_obj[1] ;
17907
17908 if (!args) SWIG_fail;
17909 swig_obj[0] = args;
17910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17911 if (!SWIG_IsOK(res1)) {
17912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17913 }
17914 arg1 = reinterpret_cast< wxImage * >(argp1);
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 result = (int)(arg1)->GetHeight();
17918 wxPyEndAllowThreads(__tstate);
17919 if (PyErr_Occurred()) SWIG_fail;
17920 }
17921 resultobj = SWIG_From_int(static_cast< int >(result));
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17929 PyObject *resultobj = 0;
17930 wxImage *arg1 = (wxImage *) 0 ;
17931 wxSize result;
17932 void *argp1 = 0 ;
17933 int res1 = 0 ;
17934 PyObject *swig_obj[1] ;
17935
17936 if (!args) SWIG_fail;
17937 swig_obj[0] = args;
17938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17939 if (!SWIG_IsOK(res1)) {
17940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17941 }
17942 arg1 = reinterpret_cast< wxImage * >(argp1);
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 result = wxImage_GetSize(arg1);
17946 wxPyEndAllowThreads(__tstate);
17947 if (PyErr_Occurred()) SWIG_fail;
17948 }
17949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17957 PyObject *resultobj = 0;
17958 wxImage *arg1 = (wxImage *) 0 ;
17959 wxRect *arg2 = 0 ;
17960 SwigValueWrapper<wxImage > result;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 wxRect temp2 ;
17964 PyObject * obj0 = 0 ;
17965 PyObject * obj1 = 0 ;
17966 char * kwnames[] = {
17967 (char *) "self",(char *) "rect", NULL
17968 };
17969
17970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17972 if (!SWIG_IsOK(res1)) {
17973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17974 }
17975 arg1 = reinterpret_cast< wxImage * >(argp1);
17976 {
17977 arg2 = &temp2;
17978 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17979 }
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj = 0;
17995 wxImage *arg1 = (wxImage *) 0 ;
17996 wxSize *arg2 = 0 ;
17997 wxPoint *arg3 = 0 ;
17998 int arg4 = (int) -1 ;
17999 int arg5 = (int) -1 ;
18000 int arg6 = (int) -1 ;
18001 SwigValueWrapper<wxImage > result;
18002 void *argp1 = 0 ;
18003 int res1 = 0 ;
18004 wxSize temp2 ;
18005 wxPoint temp3 ;
18006 int val4 ;
18007 int ecode4 = 0 ;
18008 int val5 ;
18009 int ecode5 = 0 ;
18010 int val6 ;
18011 int ecode6 = 0 ;
18012 PyObject * obj0 = 0 ;
18013 PyObject * obj1 = 0 ;
18014 PyObject * obj2 = 0 ;
18015 PyObject * obj3 = 0 ;
18016 PyObject * obj4 = 0 ;
18017 PyObject * obj5 = 0 ;
18018 char * kwnames[] = {
18019 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18020 };
18021
18022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18024 if (!SWIG_IsOK(res1)) {
18025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18026 }
18027 arg1 = reinterpret_cast< wxImage * >(argp1);
18028 {
18029 arg2 = &temp2;
18030 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18031 }
18032 {
18033 arg3 = &temp3;
18034 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18035 }
18036 if (obj3) {
18037 ecode4 = SWIG_AsVal_int(obj3, &val4);
18038 if (!SWIG_IsOK(ecode4)) {
18039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18040 }
18041 arg4 = static_cast< int >(val4);
18042 }
18043 if (obj4) {
18044 ecode5 = SWIG_AsVal_int(obj4, &val5);
18045 if (!SWIG_IsOK(ecode5)) {
18046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18047 }
18048 arg5 = static_cast< int >(val5);
18049 }
18050 if (obj5) {
18051 ecode6 = SWIG_AsVal_int(obj5, &val6);
18052 if (!SWIG_IsOK(ecode6)) {
18053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18054 }
18055 arg6 = static_cast< int >(val6);
18056 }
18057 {
18058 PyThreadState* __tstate = wxPyBeginAllowThreads();
18059 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18060 wxPyEndAllowThreads(__tstate);
18061 if (PyErr_Occurred()) SWIG_fail;
18062 }
18063 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18071 PyObject *resultobj = 0;
18072 wxImage *arg1 = (wxImage *) 0 ;
18073 SwigValueWrapper<wxImage > result;
18074 void *argp1 = 0 ;
18075 int res1 = 0 ;
18076 PyObject *swig_obj[1] ;
18077
18078 if (!args) SWIG_fail;
18079 swig_obj[0] = args;
18080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18081 if (!SWIG_IsOK(res1)) {
18082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18083 }
18084 arg1 = reinterpret_cast< wxImage * >(argp1);
18085 {
18086 PyThreadState* __tstate = wxPyBeginAllowThreads();
18087 result = (arg1)->Copy();
18088 wxPyEndAllowThreads(__tstate);
18089 if (PyErr_Occurred()) SWIG_fail;
18090 }
18091 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18092 return resultobj;
18093 fail:
18094 return NULL;
18095 }
18096
18097
18098 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18099 PyObject *resultobj = 0;
18100 wxImage *arg1 = (wxImage *) 0 ;
18101 wxImage *arg2 = 0 ;
18102 int arg3 ;
18103 int arg4 ;
18104 void *argp1 = 0 ;
18105 int res1 = 0 ;
18106 void *argp2 = 0 ;
18107 int res2 = 0 ;
18108 int val3 ;
18109 int ecode3 = 0 ;
18110 int val4 ;
18111 int ecode4 = 0 ;
18112 PyObject * obj0 = 0 ;
18113 PyObject * obj1 = 0 ;
18114 PyObject * obj2 = 0 ;
18115 PyObject * obj3 = 0 ;
18116 char * kwnames[] = {
18117 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18118 };
18119
18120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18122 if (!SWIG_IsOK(res1)) {
18123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18124 }
18125 arg1 = reinterpret_cast< wxImage * >(argp1);
18126 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18127 if (!SWIG_IsOK(res2)) {
18128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18129 }
18130 if (!argp2) {
18131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18132 }
18133 arg2 = reinterpret_cast< wxImage * >(argp2);
18134 ecode3 = SWIG_AsVal_int(obj2, &val3);
18135 if (!SWIG_IsOK(ecode3)) {
18136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18137 }
18138 arg3 = static_cast< int >(val3);
18139 ecode4 = SWIG_AsVal_int(obj3, &val4);
18140 if (!SWIG_IsOK(ecode4)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18142 }
18143 arg4 = static_cast< int >(val4);
18144 {
18145 PyThreadState* __tstate = wxPyBeginAllowThreads();
18146 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 resultobj = SWIG_Py_Void();
18151 return resultobj;
18152 fail:
18153 return NULL;
18154 }
18155
18156
18157 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18158 PyObject *resultobj = 0;
18159 wxImage *arg1 = (wxImage *) 0 ;
18160 PyObject *result = 0 ;
18161 void *argp1 = 0 ;
18162 int res1 = 0 ;
18163 PyObject *swig_obj[1] ;
18164
18165 if (!args) SWIG_fail;
18166 swig_obj[0] = args;
18167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18168 if (!SWIG_IsOK(res1)) {
18169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18170 }
18171 arg1 = reinterpret_cast< wxImage * >(argp1);
18172 {
18173 PyThreadState* __tstate = wxPyBeginAllowThreads();
18174 result = (PyObject *)wxImage_GetData(arg1);
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 resultobj = result;
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj = 0;
18187 wxImage *arg1 = (wxImage *) 0 ;
18188 buffer arg2 ;
18189 int arg3 ;
18190 void *argp1 = 0 ;
18191 int res1 = 0 ;
18192 Py_ssize_t temp2 ;
18193 PyObject * obj0 = 0 ;
18194 PyObject * obj1 = 0 ;
18195 char * kwnames[] = {
18196 (char *) "self",(char *) "data", NULL
18197 };
18198
18199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18203 }
18204 arg1 = reinterpret_cast< wxImage * >(argp1);
18205 {
18206 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18207 arg3 = (int)temp2;
18208 }
18209 {
18210 PyThreadState* __tstate = wxPyBeginAllowThreads();
18211 wxImage_SetData(arg1,arg2,arg3);
18212 wxPyEndAllowThreads(__tstate);
18213 if (PyErr_Occurred()) SWIG_fail;
18214 }
18215 resultobj = SWIG_Py_Void();
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18223 PyObject *resultobj = 0;
18224 wxImage *arg1 = (wxImage *) 0 ;
18225 PyObject *result = 0 ;
18226 void *argp1 = 0 ;
18227 int res1 = 0 ;
18228 PyObject *swig_obj[1] ;
18229
18230 if (!args) SWIG_fail;
18231 swig_obj[0] = args;
18232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18233 if (!SWIG_IsOK(res1)) {
18234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18235 }
18236 arg1 = reinterpret_cast< wxImage * >(argp1);
18237 {
18238 PyThreadState* __tstate = wxPyBeginAllowThreads();
18239 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 resultobj = result;
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj = 0;
18252 wxImage *arg1 = (wxImage *) 0 ;
18253 buffer arg2 ;
18254 int arg3 ;
18255 void *argp1 = 0 ;
18256 int res1 = 0 ;
18257 Py_ssize_t temp2 ;
18258 PyObject * obj0 = 0 ;
18259 PyObject * obj1 = 0 ;
18260 char * kwnames[] = {
18261 (char *) "self",(char *) "data", NULL
18262 };
18263
18264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18266 if (!SWIG_IsOK(res1)) {
18267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18268 }
18269 arg1 = reinterpret_cast< wxImage * >(argp1);
18270 {
18271 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18272 arg3 = (int)temp2;
18273 }
18274 {
18275 PyThreadState* __tstate = wxPyBeginAllowThreads();
18276 wxImage_SetDataBuffer(arg1,arg2,arg3);
18277 wxPyEndAllowThreads(__tstate);
18278 if (PyErr_Occurred()) SWIG_fail;
18279 }
18280 resultobj = SWIG_Py_Void();
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18288 PyObject *resultobj = 0;
18289 wxImage *arg1 = (wxImage *) 0 ;
18290 PyObject *result = 0 ;
18291 void *argp1 = 0 ;
18292 int res1 = 0 ;
18293 PyObject *swig_obj[1] ;
18294
18295 if (!args) SWIG_fail;
18296 swig_obj[0] = args;
18297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18298 if (!SWIG_IsOK(res1)) {
18299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18300 }
18301 arg1 = reinterpret_cast< wxImage * >(argp1);
18302 {
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 result = (PyObject *)wxImage_GetAlphaData(arg1);
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 resultobj = result;
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj = 0;
18317 wxImage *arg1 = (wxImage *) 0 ;
18318 buffer arg2 ;
18319 int arg3 ;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 Py_ssize_t temp2 ;
18323 PyObject * obj0 = 0 ;
18324 PyObject * obj1 = 0 ;
18325 char * kwnames[] = {
18326 (char *) "self",(char *) "alpha", NULL
18327 };
18328
18329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18331 if (!SWIG_IsOK(res1)) {
18332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18333 }
18334 arg1 = reinterpret_cast< wxImage * >(argp1);
18335 {
18336 if (obj1 != Py_None) {
18337 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18338 arg3 = (int)temp2;
18339 }
18340 }
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 wxImage_SetAlphaData(arg1,arg2,arg3);
18344 wxPyEndAllowThreads(__tstate);
18345 if (PyErr_Occurred()) SWIG_fail;
18346 }
18347 resultobj = SWIG_Py_Void();
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18355 PyObject *resultobj = 0;
18356 wxImage *arg1 = (wxImage *) 0 ;
18357 PyObject *result = 0 ;
18358 void *argp1 = 0 ;
18359 int res1 = 0 ;
18360 PyObject *swig_obj[1] ;
18361
18362 if (!args) SWIG_fail;
18363 swig_obj[0] = args;
18364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18365 if (!SWIG_IsOK(res1)) {
18366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18367 }
18368 arg1 = reinterpret_cast< wxImage * >(argp1);
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18372 wxPyEndAllowThreads(__tstate);
18373 if (PyErr_Occurred()) SWIG_fail;
18374 }
18375 resultobj = result;
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj = 0;
18384 wxImage *arg1 = (wxImage *) 0 ;
18385 buffer arg2 ;
18386 int arg3 ;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 Py_ssize_t temp2 ;
18390 PyObject * obj0 = 0 ;
18391 PyObject * obj1 = 0 ;
18392 char * kwnames[] = {
18393 (char *) "self",(char *) "alpha", NULL
18394 };
18395
18396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18398 if (!SWIG_IsOK(res1)) {
18399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18400 }
18401 arg1 = reinterpret_cast< wxImage * >(argp1);
18402 {
18403 if (obj1 != Py_None) {
18404 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18405 arg3 = (int)temp2;
18406 }
18407 }
18408 {
18409 PyThreadState* __tstate = wxPyBeginAllowThreads();
18410 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18411 wxPyEndAllowThreads(__tstate);
18412 if (PyErr_Occurred()) SWIG_fail;
18413 }
18414 resultobj = SWIG_Py_Void();
18415 return resultobj;
18416 fail:
18417 return NULL;
18418 }
18419
18420
18421 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18422 PyObject *resultobj = 0;
18423 wxImage *arg1 = (wxImage *) 0 ;
18424 byte arg2 ;
18425 byte arg3 ;
18426 byte arg4 ;
18427 void *argp1 = 0 ;
18428 int res1 = 0 ;
18429 unsigned char val2 ;
18430 int ecode2 = 0 ;
18431 unsigned char val3 ;
18432 int ecode3 = 0 ;
18433 unsigned char val4 ;
18434 int ecode4 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 PyObject * obj2 = 0 ;
18438 PyObject * obj3 = 0 ;
18439 char * kwnames[] = {
18440 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18441 };
18442
18443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18447 }
18448 arg1 = reinterpret_cast< wxImage * >(argp1);
18449 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18450 if (!SWIG_IsOK(ecode2)) {
18451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18452 }
18453 arg2 = static_cast< byte >(val2);
18454 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18455 if (!SWIG_IsOK(ecode3)) {
18456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18457 }
18458 arg3 = static_cast< byte >(val3);
18459 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18460 if (!SWIG_IsOK(ecode4)) {
18461 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18462 }
18463 arg4 = static_cast< byte >(val4);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 (arg1)->SetMaskColour(arg2,arg3,arg4);
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 resultobj = SWIG_Py_Void();
18471 return resultobj;
18472 fail:
18473 return NULL;
18474 }
18475
18476
18477 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18478 PyObject *resultobj = 0;
18479 wxImage *arg1 = (wxImage *) 0 ;
18480 byte *arg2 = (byte *) 0 ;
18481 byte *arg3 = (byte *) 0 ;
18482 byte *arg4 = (byte *) 0 ;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 byte temp2 ;
18486 int res2 = SWIG_TMPOBJ ;
18487 byte temp3 ;
18488 int res3 = SWIG_TMPOBJ ;
18489 byte temp4 ;
18490 int res4 = SWIG_TMPOBJ ;
18491 PyObject *swig_obj[1] ;
18492
18493 arg2 = &temp2;
18494 arg3 = &temp3;
18495 arg4 = &temp4;
18496 if (!args) SWIG_fail;
18497 swig_obj[0] = args;
18498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18499 if (!SWIG_IsOK(res1)) {
18500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18501 }
18502 arg1 = reinterpret_cast< wxImage * >(argp1);
18503 {
18504 PyThreadState* __tstate = wxPyBeginAllowThreads();
18505 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18506 wxPyEndAllowThreads(__tstate);
18507 if (PyErr_Occurred()) SWIG_fail;
18508 }
18509 resultobj = SWIG_Py_Void();
18510 if (SWIG_IsTmpObj(res2)) {
18511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18512 } else {
18513 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18515 }
18516 if (SWIG_IsTmpObj(res3)) {
18517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18518 } else {
18519 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18521 }
18522 if (SWIG_IsTmpObj(res4)) {
18523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18524 } else {
18525 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18527 }
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18535 PyObject *resultobj = 0;
18536 wxImage *arg1 = (wxImage *) 0 ;
18537 byte result;
18538 void *argp1 = 0 ;
18539 int res1 = 0 ;
18540 PyObject *swig_obj[1] ;
18541
18542 if (!args) SWIG_fail;
18543 swig_obj[0] = args;
18544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18545 if (!SWIG_IsOK(res1)) {
18546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18547 }
18548 arg1 = reinterpret_cast< wxImage * >(argp1);
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 result = (byte)(arg1)->GetMaskRed();
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18556 return resultobj;
18557 fail:
18558 return NULL;
18559 }
18560
18561
18562 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18563 PyObject *resultobj = 0;
18564 wxImage *arg1 = (wxImage *) 0 ;
18565 byte result;
18566 void *argp1 = 0 ;
18567 int res1 = 0 ;
18568 PyObject *swig_obj[1] ;
18569
18570 if (!args) SWIG_fail;
18571 swig_obj[0] = args;
18572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18573 if (!SWIG_IsOK(res1)) {
18574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18575 }
18576 arg1 = reinterpret_cast< wxImage * >(argp1);
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 result = (byte)(arg1)->GetMaskGreen();
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18591 PyObject *resultobj = 0;
18592 wxImage *arg1 = (wxImage *) 0 ;
18593 byte result;
18594 void *argp1 = 0 ;
18595 int res1 = 0 ;
18596 PyObject *swig_obj[1] ;
18597
18598 if (!args) SWIG_fail;
18599 swig_obj[0] = args;
18600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18601 if (!SWIG_IsOK(res1)) {
18602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18603 }
18604 arg1 = reinterpret_cast< wxImage * >(argp1);
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 result = (byte)(arg1)->GetMaskBlue();
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj = 0;
18620 wxImage *arg1 = (wxImage *) 0 ;
18621 bool arg2 = (bool) true ;
18622 void *argp1 = 0 ;
18623 int res1 = 0 ;
18624 bool val2 ;
18625 int ecode2 = 0 ;
18626 PyObject * obj0 = 0 ;
18627 PyObject * obj1 = 0 ;
18628 char * kwnames[] = {
18629 (char *) "self",(char *) "mask", NULL
18630 };
18631
18632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18634 if (!SWIG_IsOK(res1)) {
18635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18636 }
18637 arg1 = reinterpret_cast< wxImage * >(argp1);
18638 if (obj1) {
18639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18640 if (!SWIG_IsOK(ecode2)) {
18641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18642 }
18643 arg2 = static_cast< bool >(val2);
18644 }
18645 {
18646 PyThreadState* __tstate = wxPyBeginAllowThreads();
18647 (arg1)->SetMask(arg2);
18648 wxPyEndAllowThreads(__tstate);
18649 if (PyErr_Occurred()) SWIG_fail;
18650 }
18651 resultobj = SWIG_Py_Void();
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18659 PyObject *resultobj = 0;
18660 wxImage *arg1 = (wxImage *) 0 ;
18661 bool result;
18662 void *argp1 = 0 ;
18663 int res1 = 0 ;
18664 PyObject *swig_obj[1] ;
18665
18666 if (!args) SWIG_fail;
18667 swig_obj[0] = args;
18668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18669 if (!SWIG_IsOK(res1)) {
18670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18671 }
18672 arg1 = reinterpret_cast< wxImage * >(argp1);
18673 {
18674 PyThreadState* __tstate = wxPyBeginAllowThreads();
18675 result = (bool)(arg1)->HasMask();
18676 wxPyEndAllowThreads(__tstate);
18677 if (PyErr_Occurred()) SWIG_fail;
18678 }
18679 {
18680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18681 }
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18689 PyObject *resultobj = 0;
18690 wxImage *arg1 = (wxImage *) 0 ;
18691 double arg2 ;
18692 wxPoint *arg3 = 0 ;
18693 bool arg4 = (bool) true ;
18694 wxPoint *arg5 = (wxPoint *) NULL ;
18695 SwigValueWrapper<wxImage > result;
18696 void *argp1 = 0 ;
18697 int res1 = 0 ;
18698 double val2 ;
18699 int ecode2 = 0 ;
18700 wxPoint temp3 ;
18701 bool val4 ;
18702 int ecode4 = 0 ;
18703 void *argp5 = 0 ;
18704 int res5 = 0 ;
18705 PyObject * obj0 = 0 ;
18706 PyObject * obj1 = 0 ;
18707 PyObject * obj2 = 0 ;
18708 PyObject * obj3 = 0 ;
18709 PyObject * obj4 = 0 ;
18710 char * kwnames[] = {
18711 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18712 };
18713
18714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18716 if (!SWIG_IsOK(res1)) {
18717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18718 }
18719 arg1 = reinterpret_cast< wxImage * >(argp1);
18720 ecode2 = SWIG_AsVal_double(obj1, &val2);
18721 if (!SWIG_IsOK(ecode2)) {
18722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18723 }
18724 arg2 = static_cast< double >(val2);
18725 {
18726 arg3 = &temp3;
18727 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18728 }
18729 if (obj3) {
18730 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18731 if (!SWIG_IsOK(ecode4)) {
18732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18733 }
18734 arg4 = static_cast< bool >(val4);
18735 }
18736 if (obj4) {
18737 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18738 if (!SWIG_IsOK(res5)) {
18739 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18740 }
18741 arg5 = reinterpret_cast< wxPoint * >(argp5);
18742 }
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj = 0;
18758 wxImage *arg1 = (wxImage *) 0 ;
18759 bool arg2 = (bool) true ;
18760 SwigValueWrapper<wxImage > result;
18761 void *argp1 = 0 ;
18762 int res1 = 0 ;
18763 bool val2 ;
18764 int ecode2 = 0 ;
18765 PyObject * obj0 = 0 ;
18766 PyObject * obj1 = 0 ;
18767 char * kwnames[] = {
18768 (char *) "self",(char *) "clockwise", NULL
18769 };
18770
18771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18773 if (!SWIG_IsOK(res1)) {
18774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18775 }
18776 arg1 = reinterpret_cast< wxImage * >(argp1);
18777 if (obj1) {
18778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18779 if (!SWIG_IsOK(ecode2)) {
18780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18781 }
18782 arg2 = static_cast< bool >(val2);
18783 }
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = (arg1)->Rotate90(arg2);
18787 wxPyEndAllowThreads(__tstate);
18788 if (PyErr_Occurred()) SWIG_fail;
18789 }
18790 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj = 0;
18799 wxImage *arg1 = (wxImage *) 0 ;
18800 bool arg2 = (bool) true ;
18801 SwigValueWrapper<wxImage > result;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 bool val2 ;
18805 int ecode2 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "horizontally", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18816 }
18817 arg1 = reinterpret_cast< wxImage * >(argp1);
18818 if (obj1) {
18819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18820 if (!SWIG_IsOK(ecode2)) {
18821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18822 }
18823 arg2 = static_cast< bool >(val2);
18824 }
18825 {
18826 PyThreadState* __tstate = wxPyBeginAllowThreads();
18827 result = (arg1)->Mirror(arg2);
18828 wxPyEndAllowThreads(__tstate);
18829 if (PyErr_Occurred()) SWIG_fail;
18830 }
18831 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18832 return resultobj;
18833 fail:
18834 return NULL;
18835 }
18836
18837
18838 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18839 PyObject *resultobj = 0;
18840 wxImage *arg1 = (wxImage *) 0 ;
18841 byte arg2 ;
18842 byte arg3 ;
18843 byte arg4 ;
18844 byte arg5 ;
18845 byte arg6 ;
18846 byte arg7 ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 unsigned char val2 ;
18850 int ecode2 = 0 ;
18851 unsigned char val3 ;
18852 int ecode3 = 0 ;
18853 unsigned char val4 ;
18854 int ecode4 = 0 ;
18855 unsigned char val5 ;
18856 int ecode5 = 0 ;
18857 unsigned char val6 ;
18858 int ecode6 = 0 ;
18859 unsigned char val7 ;
18860 int ecode7 = 0 ;
18861 PyObject * obj0 = 0 ;
18862 PyObject * obj1 = 0 ;
18863 PyObject * obj2 = 0 ;
18864 PyObject * obj3 = 0 ;
18865 PyObject * obj4 = 0 ;
18866 PyObject * obj5 = 0 ;
18867 PyObject * obj6 = 0 ;
18868 char * kwnames[] = {
18869 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18870 };
18871
18872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18876 }
18877 arg1 = reinterpret_cast< wxImage * >(argp1);
18878 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18879 if (!SWIG_IsOK(ecode2)) {
18880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18881 }
18882 arg2 = static_cast< byte >(val2);
18883 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18884 if (!SWIG_IsOK(ecode3)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18886 }
18887 arg3 = static_cast< byte >(val3);
18888 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18889 if (!SWIG_IsOK(ecode4)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18891 }
18892 arg4 = static_cast< byte >(val4);
18893 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18894 if (!SWIG_IsOK(ecode5)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18896 }
18897 arg5 = static_cast< byte >(val5);
18898 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18899 if (!SWIG_IsOK(ecode6)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18901 }
18902 arg6 = static_cast< byte >(val6);
18903 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18904 if (!SWIG_IsOK(ecode7)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18906 }
18907 arg7 = static_cast< byte >(val7);
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18911 wxPyEndAllowThreads(__tstate);
18912 if (PyErr_Occurred()) SWIG_fail;
18913 }
18914 resultobj = SWIG_Py_Void();
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj = 0;
18923 wxImage *arg1 = (wxImage *) 0 ;
18924 double arg2 = (double) 0.299 ;
18925 double arg3 = (double) 0.587 ;
18926 double arg4 = (double) 0.114 ;
18927 SwigValueWrapper<wxImage > result;
18928 void *argp1 = 0 ;
18929 int res1 = 0 ;
18930 double val2 ;
18931 int ecode2 = 0 ;
18932 double val3 ;
18933 int ecode3 = 0 ;
18934 double val4 ;
18935 int ecode4 = 0 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 PyObject * obj2 = 0 ;
18939 PyObject * obj3 = 0 ;
18940 char * kwnames[] = {
18941 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18942 };
18943
18944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18946 if (!SWIG_IsOK(res1)) {
18947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18948 }
18949 arg1 = reinterpret_cast< wxImage * >(argp1);
18950 if (obj1) {
18951 ecode2 = SWIG_AsVal_double(obj1, &val2);
18952 if (!SWIG_IsOK(ecode2)) {
18953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18954 }
18955 arg2 = static_cast< double >(val2);
18956 }
18957 if (obj2) {
18958 ecode3 = SWIG_AsVal_double(obj2, &val3);
18959 if (!SWIG_IsOK(ecode3)) {
18960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18961 }
18962 arg3 = static_cast< double >(val3);
18963 }
18964 if (obj3) {
18965 ecode4 = SWIG_AsVal_double(obj3, &val4);
18966 if (!SWIG_IsOK(ecode4)) {
18967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18968 }
18969 arg4 = static_cast< double >(val4);
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj = 0;
18986 wxImage *arg1 = (wxImage *) 0 ;
18987 byte arg2 ;
18988 byte arg3 ;
18989 byte arg4 ;
18990 SwigValueWrapper<wxImage > result;
18991 void *argp1 = 0 ;
18992 int res1 = 0 ;
18993 unsigned char val2 ;
18994 int ecode2 = 0 ;
18995 unsigned char val3 ;
18996 int ecode3 = 0 ;
18997 unsigned char val4 ;
18998 int ecode4 = 0 ;
18999 PyObject * obj0 = 0 ;
19000 PyObject * obj1 = 0 ;
19001 PyObject * obj2 = 0 ;
19002 PyObject * obj3 = 0 ;
19003 char * kwnames[] = {
19004 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19005 };
19006
19007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19009 if (!SWIG_IsOK(res1)) {
19010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19011 }
19012 arg1 = reinterpret_cast< wxImage * >(argp1);
19013 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19014 if (!SWIG_IsOK(ecode2)) {
19015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19016 }
19017 arg2 = static_cast< byte >(val2);
19018 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19019 if (!SWIG_IsOK(ecode3)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19021 }
19022 arg3 = static_cast< byte >(val3);
19023 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19024 if (!SWIG_IsOK(ecode4)) {
19025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19026 }
19027 arg4 = static_cast< byte >(val4);
19028 {
19029 PyThreadState* __tstate = wxPyBeginAllowThreads();
19030 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19031 wxPyEndAllowThreads(__tstate);
19032 if (PyErr_Occurred()) SWIG_fail;
19033 }
19034 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19035 return resultobj;
19036 fail:
19037 return NULL;
19038 }
19039
19040
19041 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj = 0;
19043 wxImage *arg1 = (wxImage *) 0 ;
19044 wxString *arg2 = 0 ;
19045 wxString *arg3 = 0 ;
19046 void *argp1 = 0 ;
19047 int res1 = 0 ;
19048 bool temp2 = false ;
19049 bool temp3 = false ;
19050 PyObject * obj0 = 0 ;
19051 PyObject * obj1 = 0 ;
19052 PyObject * obj2 = 0 ;
19053 char * kwnames[] = {
19054 (char *) "self",(char *) "name",(char *) "value", NULL
19055 };
19056
19057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19059 if (!SWIG_IsOK(res1)) {
19060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19061 }
19062 arg1 = reinterpret_cast< wxImage * >(argp1);
19063 {
19064 arg2 = wxString_in_helper(obj1);
19065 if (arg2 == NULL) SWIG_fail;
19066 temp2 = true;
19067 }
19068 {
19069 arg3 = wxString_in_helper(obj2);
19070 if (arg3 == NULL) SWIG_fail;
19071 temp3 = true;
19072 }
19073 {
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 resultobj = SWIG_Py_Void();
19080 {
19081 if (temp2)
19082 delete arg2;
19083 }
19084 {
19085 if (temp3)
19086 delete arg3;
19087 }
19088 return resultobj;
19089 fail:
19090 {
19091 if (temp2)
19092 delete arg2;
19093 }
19094 {
19095 if (temp3)
19096 delete arg3;
19097 }
19098 return NULL;
19099 }
19100
19101
19102 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19103 PyObject *resultobj = 0;
19104 wxImage *arg1 = (wxImage *) 0 ;
19105 wxString *arg2 = 0 ;
19106 int arg3 ;
19107 void *argp1 = 0 ;
19108 int res1 = 0 ;
19109 bool temp2 = false ;
19110 int val3 ;
19111 int ecode3 = 0 ;
19112 PyObject * obj0 = 0 ;
19113 PyObject * obj1 = 0 ;
19114 PyObject * obj2 = 0 ;
19115 char * kwnames[] = {
19116 (char *) "self",(char *) "name",(char *) "value", NULL
19117 };
19118
19119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19121 if (!SWIG_IsOK(res1)) {
19122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19123 }
19124 arg1 = reinterpret_cast< wxImage * >(argp1);
19125 {
19126 arg2 = wxString_in_helper(obj1);
19127 if (arg2 == NULL) SWIG_fail;
19128 temp2 = true;
19129 }
19130 ecode3 = SWIG_AsVal_int(obj2, &val3);
19131 if (!SWIG_IsOK(ecode3)) {
19132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19133 }
19134 arg3 = static_cast< int >(val3);
19135 {
19136 PyThreadState* __tstate = wxPyBeginAllowThreads();
19137 (arg1)->SetOption((wxString const &)*arg2,arg3);
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 resultobj = SWIG_Py_Void();
19142 {
19143 if (temp2)
19144 delete arg2;
19145 }
19146 return resultobj;
19147 fail:
19148 {
19149 if (temp2)
19150 delete arg2;
19151 }
19152 return NULL;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj = 0;
19158 wxImage *arg1 = (wxImage *) 0 ;
19159 wxString *arg2 = 0 ;
19160 wxString result;
19161 void *argp1 = 0 ;
19162 int res1 = 0 ;
19163 bool temp2 = false ;
19164 PyObject * obj0 = 0 ;
19165 PyObject * obj1 = 0 ;
19166 char * kwnames[] = {
19167 (char *) "self",(char *) "name", NULL
19168 };
19169
19170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19172 if (!SWIG_IsOK(res1)) {
19173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19174 }
19175 arg1 = reinterpret_cast< wxImage * >(argp1);
19176 {
19177 arg2 = wxString_in_helper(obj1);
19178 if (arg2 == NULL) SWIG_fail;
19179 temp2 = true;
19180 }
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 {
19188 #if wxUSE_UNICODE
19189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19190 #else
19191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19192 #endif
19193 }
19194 {
19195 if (temp2)
19196 delete arg2;
19197 }
19198 return resultobj;
19199 fail:
19200 {
19201 if (temp2)
19202 delete arg2;
19203 }
19204 return NULL;
19205 }
19206
19207
19208 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj = 0;
19210 wxImage *arg1 = (wxImage *) 0 ;
19211 wxString *arg2 = 0 ;
19212 int result;
19213 void *argp1 = 0 ;
19214 int res1 = 0 ;
19215 bool temp2 = false ;
19216 PyObject * obj0 = 0 ;
19217 PyObject * obj1 = 0 ;
19218 char * kwnames[] = {
19219 (char *) "self",(char *) "name", NULL
19220 };
19221
19222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19224 if (!SWIG_IsOK(res1)) {
19225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19226 }
19227 arg1 = reinterpret_cast< wxImage * >(argp1);
19228 {
19229 arg2 = wxString_in_helper(obj1);
19230 if (arg2 == NULL) SWIG_fail;
19231 temp2 = true;
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_From_int(static_cast< int >(result));
19240 {
19241 if (temp2)
19242 delete arg2;
19243 }
19244 return resultobj;
19245 fail:
19246 {
19247 if (temp2)
19248 delete arg2;
19249 }
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19255 PyObject *resultobj = 0;
19256 wxImage *arg1 = (wxImage *) 0 ;
19257 wxString *arg2 = 0 ;
19258 bool result;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 bool temp2 = false ;
19262 PyObject * obj0 = 0 ;
19263 PyObject * obj1 = 0 ;
19264 char * kwnames[] = {
19265 (char *) "self",(char *) "name", NULL
19266 };
19267
19268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19272 }
19273 arg1 = reinterpret_cast< wxImage * >(argp1);
19274 {
19275 arg2 = wxString_in_helper(obj1);
19276 if (arg2 == NULL) SWIG_fail;
19277 temp2 = true;
19278 }
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 {
19289 if (temp2)
19290 delete arg2;
19291 }
19292 return resultobj;
19293 fail:
19294 {
19295 if (temp2)
19296 delete arg2;
19297 }
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj = 0;
19304 wxImage *arg1 = (wxImage *) 0 ;
19305 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19306 unsigned long result;
19307 void *argp1 = 0 ;
19308 int res1 = 0 ;
19309 unsigned long val2 ;
19310 int ecode2 = 0 ;
19311 PyObject * obj0 = 0 ;
19312 PyObject * obj1 = 0 ;
19313 char * kwnames[] = {
19314 (char *) "self",(char *) "stopafter", NULL
19315 };
19316
19317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19319 if (!SWIG_IsOK(res1)) {
19320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19321 }
19322 arg1 = reinterpret_cast< wxImage * >(argp1);
19323 if (obj1) {
19324 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19325 if (!SWIG_IsOK(ecode2)) {
19326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19327 }
19328 arg2 = static_cast< unsigned long >(val2);
19329 }
19330 {
19331 PyThreadState* __tstate = wxPyBeginAllowThreads();
19332 result = (unsigned long)(arg1)->CountColours(arg2);
19333 wxPyEndAllowThreads(__tstate);
19334 if (PyErr_Occurred()) SWIG_fail;
19335 }
19336 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19337 return resultobj;
19338 fail:
19339 return NULL;
19340 }
19341
19342
19343 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19344 PyObject *resultobj = 0;
19345 wxImage *arg1 = (wxImage *) 0 ;
19346 wxImageHistogram *arg2 = 0 ;
19347 unsigned long result;
19348 void *argp1 = 0 ;
19349 int res1 = 0 ;
19350 void *argp2 = 0 ;
19351 int res2 = 0 ;
19352 PyObject * obj0 = 0 ;
19353 PyObject * obj1 = 0 ;
19354 char * kwnames[] = {
19355 (char *) "self",(char *) "h", NULL
19356 };
19357
19358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19360 if (!SWIG_IsOK(res1)) {
19361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19362 }
19363 arg1 = reinterpret_cast< wxImage * >(argp1);
19364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19365 if (!SWIG_IsOK(res2)) {
19366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19367 }
19368 if (!argp2) {
19369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19370 }
19371 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19379 return resultobj;
19380 fail:
19381 return NULL;
19382 }
19383
19384
19385 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19386 PyObject *resultobj = 0;
19387 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19388 void *argp1 = 0 ;
19389 int res1 = 0 ;
19390 PyObject * obj0 = 0 ;
19391 char * kwnames[] = {
19392 (char *) "handler", NULL
19393 };
19394
19395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19397 if (!SWIG_IsOK(res1)) {
19398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19399 }
19400 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 wxImage::AddHandler(arg1);
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 resultobj = SWIG_Py_Void();
19408 return resultobj;
19409 fail:
19410 return NULL;
19411 }
19412
19413
19414 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19415 PyObject *resultobj = 0;
19416 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19417 void *argp1 = 0 ;
19418 int res1 = 0 ;
19419 PyObject * obj0 = 0 ;
19420 char * kwnames[] = {
19421 (char *) "handler", NULL
19422 };
19423
19424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19426 if (!SWIG_IsOK(res1)) {
19427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19428 }
19429 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19430 {
19431 PyThreadState* __tstate = wxPyBeginAllowThreads();
19432 wxImage::InsertHandler(arg1);
19433 wxPyEndAllowThreads(__tstate);
19434 if (PyErr_Occurred()) SWIG_fail;
19435 }
19436 resultobj = SWIG_Py_Void();
19437 return resultobj;
19438 fail:
19439 return NULL;
19440 }
19441
19442
19443 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj = 0;
19445 wxString *arg1 = 0 ;
19446 bool result;
19447 bool temp1 = false ;
19448 PyObject * obj0 = 0 ;
19449 char * kwnames[] = {
19450 (char *) "name", NULL
19451 };
19452
19453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19454 {
19455 arg1 = wxString_in_helper(obj0);
19456 if (arg1 == NULL) SWIG_fail;
19457 temp1 = true;
19458 }
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 {
19466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19467 }
19468 {
19469 if (temp1)
19470 delete arg1;
19471 }
19472 return resultobj;
19473 fail:
19474 {
19475 if (temp1)
19476 delete arg1;
19477 }
19478 return NULL;
19479 }
19480
19481
19482 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19483 PyObject *resultobj = 0;
19484 PyObject *result = 0 ;
19485
19486 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19487 {
19488 PyThreadState* __tstate = wxPyBeginAllowThreads();
19489 result = (PyObject *)wxImage_GetHandlers();
19490 wxPyEndAllowThreads(__tstate);
19491 if (PyErr_Occurred()) SWIG_fail;
19492 }
19493 resultobj = result;
19494 return resultobj;
19495 fail:
19496 return NULL;
19497 }
19498
19499
19500 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19501 PyObject *resultobj = 0;
19502 wxString result;
19503
19504 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 result = wxImage::GetImageExtWildcard();
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 {
19512 #if wxUSE_UNICODE
19513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19514 #else
19515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19516 #endif
19517 }
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxImage *arg1 = (wxImage *) 0 ;
19527 int arg2 = (int) -1 ;
19528 wxBitmap result;
19529 void *argp1 = 0 ;
19530 int res1 = 0 ;
19531 int val2 ;
19532 int ecode2 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 char * kwnames[] = {
19536 (char *) "self",(char *) "depth", NULL
19537 };
19538
19539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19541 if (!SWIG_IsOK(res1)) {
19542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19543 }
19544 arg1 = reinterpret_cast< wxImage * >(argp1);
19545 if (obj1) {
19546 ecode2 = SWIG_AsVal_int(obj1, &val2);
19547 if (!SWIG_IsOK(ecode2)) {
19548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19549 }
19550 arg2 = static_cast< int >(val2);
19551 }
19552 {
19553 if (!wxPyCheckForApp()) SWIG_fail;
19554 PyThreadState* __tstate = wxPyBeginAllowThreads();
19555 result = wxImage_ConvertToBitmap(arg1,arg2);
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj = 0;
19568 wxImage *arg1 = (wxImage *) 0 ;
19569 byte arg2 ;
19570 byte arg3 ;
19571 byte arg4 ;
19572 wxBitmap result;
19573 void *argp1 = 0 ;
19574 int res1 = 0 ;
19575 unsigned char val2 ;
19576 int ecode2 = 0 ;
19577 unsigned char val3 ;
19578 int ecode3 = 0 ;
19579 unsigned char val4 ;
19580 int ecode4 = 0 ;
19581 PyObject * obj0 = 0 ;
19582 PyObject * obj1 = 0 ;
19583 PyObject * obj2 = 0 ;
19584 PyObject * obj3 = 0 ;
19585 char * kwnames[] = {
19586 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19587 };
19588
19589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19591 if (!SWIG_IsOK(res1)) {
19592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19593 }
19594 arg1 = reinterpret_cast< wxImage * >(argp1);
19595 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19596 if (!SWIG_IsOK(ecode2)) {
19597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19598 }
19599 arg2 = static_cast< byte >(val2);
19600 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19601 if (!SWIG_IsOK(ecode3)) {
19602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19603 }
19604 arg3 = static_cast< byte >(val3);
19605 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19606 if (!SWIG_IsOK(ecode4)) {
19607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19608 }
19609 arg4 = static_cast< byte >(val4);
19610 {
19611 if (!wxPyCheckForApp()) SWIG_fail;
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19614 wxPyEndAllowThreads(__tstate);
19615 if (PyErr_Occurred()) SWIG_fail;
19616 }
19617 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj = 0;
19626 wxImage *arg1 = (wxImage *) 0 ;
19627 double arg2 ;
19628 void *argp1 = 0 ;
19629 int res1 = 0 ;
19630 double val2 ;
19631 int ecode2 = 0 ;
19632 PyObject * obj0 = 0 ;
19633 PyObject * obj1 = 0 ;
19634 char * kwnames[] = {
19635 (char *) "self",(char *) "angle", NULL
19636 };
19637
19638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19640 if (!SWIG_IsOK(res1)) {
19641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19642 }
19643 arg1 = reinterpret_cast< wxImage * >(argp1);
19644 ecode2 = SWIG_AsVal_double(obj1, &val2);
19645 if (!SWIG_IsOK(ecode2)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19647 }
19648 arg2 = static_cast< double >(val2);
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 (arg1)->RotateHue(arg2);
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_Py_Void();
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj = 0;
19664 wxImage_RGBValue arg1 ;
19665 wxImage_HSVValue result;
19666 void *argp1 ;
19667 int res1 = 0 ;
19668 PyObject * obj0 = 0 ;
19669 char * kwnames[] = {
19670 (char *) "rgb", NULL
19671 };
19672
19673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19674 {
19675 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19676 if (!SWIG_IsOK(res1)) {
19677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19678 }
19679 if (!argp1) {
19680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19681 } else {
19682 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19683 arg1 = *temp;
19684 if (SWIG_IsNewObj(res1)) delete temp;
19685 }
19686 }
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = wxImage::RGBtoHSV(arg1);
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj = 0;
19702 wxImage_HSVValue arg1 ;
19703 wxImage_RGBValue result;
19704 void *argp1 ;
19705 int res1 = 0 ;
19706 PyObject * obj0 = 0 ;
19707 char * kwnames[] = {
19708 (char *) "hsv", NULL
19709 };
19710
19711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19712 {
19713 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19714 if (!SWIG_IsOK(res1)) {
19715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19716 }
19717 if (!argp1) {
19718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19719 } else {
19720 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19721 arg1 = *temp;
19722 if (SWIG_IsNewObj(res1)) delete temp;
19723 }
19724 }
19725 {
19726 PyThreadState* __tstate = wxPyBeginAllowThreads();
19727 result = wxImage::HSVtoRGB(arg1);
19728 wxPyEndAllowThreads(__tstate);
19729 if (PyErr_Occurred()) SWIG_fail;
19730 }
19731 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19739 PyObject *obj;
19740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19741 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19742 return SWIG_Py_Void();
19743 }
19744
19745 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19746 return SWIG_Python_InitShadowInstance(args);
19747 }
19748
19749 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj = 0;
19751 int arg1 ;
19752 int arg2 ;
19753 buffer arg3 ;
19754 int arg4 ;
19755 buffer arg5 = (buffer) NULL ;
19756 int arg6 = (int) 0 ;
19757 wxImage *result = 0 ;
19758 int val1 ;
19759 int ecode1 = 0 ;
19760 int val2 ;
19761 int ecode2 = 0 ;
19762 Py_ssize_t temp3 ;
19763 Py_ssize_t temp5 ;
19764 PyObject * obj0 = 0 ;
19765 PyObject * obj1 = 0 ;
19766 PyObject * obj2 = 0 ;
19767 PyObject * obj3 = 0 ;
19768 char * kwnames[] = {
19769 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19770 };
19771
19772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19773 ecode1 = SWIG_AsVal_int(obj0, &val1);
19774 if (!SWIG_IsOK(ecode1)) {
19775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19776 }
19777 arg1 = static_cast< int >(val1);
19778 ecode2 = SWIG_AsVal_int(obj1, &val2);
19779 if (!SWIG_IsOK(ecode2)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19781 }
19782 arg2 = static_cast< int >(val2);
19783 {
19784 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19785 arg4 = (int)temp3;
19786 }
19787 if (obj3) {
19788 {
19789 if (obj3 != Py_None) {
19790 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19791 arg6 = (int)temp5;
19792 }
19793 }
19794 }
19795 {
19796 PyThreadState* __tstate = wxPyBeginAllowThreads();
19797 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19798 wxPyEndAllowThreads(__tstate);
19799 if (PyErr_Occurred()) SWIG_fail;
19800 }
19801 {
19802 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19803 }
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 SWIGINTERN int NullImage_set(PyObject *) {
19811 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19812 return 1;
19813 }
19814
19815
19816 SWIGINTERN PyObject *NullImage_get(void) {
19817 PyObject *pyobj = 0;
19818
19819 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19820 return pyobj;
19821 }
19822
19823
19824 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19825 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19826 return 1;
19827 }
19828
19829
19830 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19831 PyObject *pyobj = 0;
19832
19833 {
19834 #if wxUSE_UNICODE
19835 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19836 #else
19837 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19838 #endif
19839 }
19840 return pyobj;
19841 }
19842
19843
19844 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19845 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19846 return 1;
19847 }
19848
19849
19850 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19851 PyObject *pyobj = 0;
19852
19853 {
19854 #if wxUSE_UNICODE
19855 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19856 #else
19857 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19858 #endif
19859 }
19860 return pyobj;
19861 }
19862
19863
19864 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19865 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19866 return 1;
19867 }
19868
19869
19870 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19871 PyObject *pyobj = 0;
19872
19873 {
19874 #if wxUSE_UNICODE
19875 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19876 #else
19877 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19878 #endif
19879 }
19880 return pyobj;
19881 }
19882
19883
19884 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19885 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19886 return 1;
19887 }
19888
19889
19890 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19891 PyObject *pyobj = 0;
19892
19893 {
19894 #if wxUSE_UNICODE
19895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19896 #else
19897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19898 #endif
19899 }
19900 return pyobj;
19901 }
19902
19903
19904 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19905 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19906 return 1;
19907 }
19908
19909
19910 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19911 PyObject *pyobj = 0;
19912
19913 {
19914 #if wxUSE_UNICODE
19915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19916 #else
19917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19918 #endif
19919 }
19920 return pyobj;
19921 }
19922
19923
19924 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19925 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19926 return 1;
19927 }
19928
19929
19930 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19931 PyObject *pyobj = 0;
19932
19933 {
19934 #if wxUSE_UNICODE
19935 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19936 #else
19937 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19938 #endif
19939 }
19940 return pyobj;
19941 }
19942
19943
19944 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19945 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19946 return 1;
19947 }
19948
19949
19950 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19951 PyObject *pyobj = 0;
19952
19953 {
19954 #if wxUSE_UNICODE
19955 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19956 #else
19957 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19958 #endif
19959 }
19960 return pyobj;
19961 }
19962
19963
19964 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19965 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19966 return 1;
19967 }
19968
19969
19970 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19971 PyObject *pyobj = 0;
19972
19973 {
19974 #if wxUSE_UNICODE
19975 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19976 #else
19977 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19978 #endif
19979 }
19980 return pyobj;
19981 }
19982
19983
19984 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19985 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19986 return 1;
19987 }
19988
19989
19990 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19991 PyObject *pyobj = 0;
19992
19993 {
19994 #if wxUSE_UNICODE
19995 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19996 #else
19997 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19998 #endif
19999 }
20000 return pyobj;
20001 }
20002
20003
20004 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20005 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20006 return 1;
20007 }
20008
20009
20010 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20011 PyObject *pyobj = 0;
20012
20013 {
20014 #if wxUSE_UNICODE
20015 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20016 #else
20017 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20018 #endif
20019 }
20020 return pyobj;
20021 }
20022
20023
20024 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20025 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20026 return 1;
20027 }
20028
20029
20030 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20031 PyObject *pyobj = 0;
20032
20033 {
20034 #if wxUSE_UNICODE
20035 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20036 #else
20037 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20038 #endif
20039 }
20040 return pyobj;
20041 }
20042
20043
20044 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20045 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20046 return 1;
20047 }
20048
20049
20050 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20051 PyObject *pyobj = 0;
20052
20053 {
20054 #if wxUSE_UNICODE
20055 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20056 #else
20057 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20058 #endif
20059 }
20060 return pyobj;
20061 }
20062
20063
20064 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20065 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20066 return 1;
20067 }
20068
20069
20070 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20071 PyObject *pyobj = 0;
20072
20073 {
20074 #if wxUSE_UNICODE
20075 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20076 #else
20077 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20078 #endif
20079 }
20080 return pyobj;
20081 }
20082
20083
20084 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20085 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20086 return 1;
20087 }
20088
20089
20090 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20091 PyObject *pyobj = 0;
20092
20093 {
20094 #if wxUSE_UNICODE
20095 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20096 #else
20097 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20098 #endif
20099 }
20100 return pyobj;
20101 }
20102
20103
20104 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20105 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20106 return 1;
20107 }
20108
20109
20110 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20111 PyObject *pyobj = 0;
20112
20113 {
20114 #if wxUSE_UNICODE
20115 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20116 #else
20117 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20118 #endif
20119 }
20120 return pyobj;
20121 }
20122
20123
20124 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20125 PyObject *resultobj = 0;
20126 wxBMPHandler *result = 0 ;
20127
20128 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20129 {
20130 PyThreadState* __tstate = wxPyBeginAllowThreads();
20131 result = (wxBMPHandler *)new wxBMPHandler();
20132 wxPyEndAllowThreads(__tstate);
20133 if (PyErr_Occurred()) SWIG_fail;
20134 }
20135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20136 return resultobj;
20137 fail:
20138 return NULL;
20139 }
20140
20141
20142 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20143 PyObject *obj;
20144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20145 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20146 return SWIG_Py_Void();
20147 }
20148
20149 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20150 return SWIG_Python_InitShadowInstance(args);
20151 }
20152
20153 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 PyObject *resultobj = 0;
20155 wxICOHandler *result = 0 ;
20156
20157 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 result = (wxICOHandler *)new wxICOHandler();
20161 wxPyEndAllowThreads(__tstate);
20162 if (PyErr_Occurred()) SWIG_fail;
20163 }
20164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20165 return resultobj;
20166 fail:
20167 return NULL;
20168 }
20169
20170
20171 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *obj;
20173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20174 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20175 return SWIG_Py_Void();
20176 }
20177
20178 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20179 return SWIG_Python_InitShadowInstance(args);
20180 }
20181
20182 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxCURHandler *result = 0 ;
20185
20186 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 result = (wxCURHandler *)new wxCURHandler();
20190 wxPyEndAllowThreads(__tstate);
20191 if (PyErr_Occurred()) SWIG_fail;
20192 }
20193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20194 return resultobj;
20195 fail:
20196 return NULL;
20197 }
20198
20199
20200 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *obj;
20202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20203 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20204 return SWIG_Py_Void();
20205 }
20206
20207 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20208 return SWIG_Python_InitShadowInstance(args);
20209 }
20210
20211 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20212 PyObject *resultobj = 0;
20213 wxANIHandler *result = 0 ;
20214
20215 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (wxANIHandler *)new wxANIHandler();
20219 wxPyEndAllowThreads(__tstate);
20220 if (PyErr_Occurred()) SWIG_fail;
20221 }
20222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20223 return resultobj;
20224 fail:
20225 return NULL;
20226 }
20227
20228
20229 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *obj;
20231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20232 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20233 return SWIG_Py_Void();
20234 }
20235
20236 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20237 return SWIG_Python_InitShadowInstance(args);
20238 }
20239
20240 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20241 PyObject *resultobj = 0;
20242 wxPNGHandler *result = 0 ;
20243
20244 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (wxPNGHandler *)new wxPNGHandler();
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20252 return resultobj;
20253 fail:
20254 return NULL;
20255 }
20256
20257
20258 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *obj;
20260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20261 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20262 return SWIG_Py_Void();
20263 }
20264
20265 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20266 return SWIG_Python_InitShadowInstance(args);
20267 }
20268
20269 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 PyObject *resultobj = 0;
20271 wxGIFHandler *result = 0 ;
20272
20273 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20274 {
20275 PyThreadState* __tstate = wxPyBeginAllowThreads();
20276 result = (wxGIFHandler *)new wxGIFHandler();
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *obj;
20289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20290 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20291 return SWIG_Py_Void();
20292 }
20293
20294 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 return SWIG_Python_InitShadowInstance(args);
20296 }
20297
20298 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 PyObject *resultobj = 0;
20300 wxPCXHandler *result = 0 ;
20301
20302 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 result = (wxPCXHandler *)new wxPCXHandler();
20306 wxPyEndAllowThreads(__tstate);
20307 if (PyErr_Occurred()) SWIG_fail;
20308 }
20309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20310 return resultobj;
20311 fail:
20312 return NULL;
20313 }
20314
20315
20316 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *obj;
20318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20320 return SWIG_Py_Void();
20321 }
20322
20323 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20324 return SWIG_Python_InitShadowInstance(args);
20325 }
20326
20327 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxJPEGHandler *result = 0 ;
20330
20331 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 result = (wxJPEGHandler *)new wxJPEGHandler();
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *obj;
20347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20348 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20349 return SWIG_Py_Void();
20350 }
20351
20352 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20353 return SWIG_Python_InitShadowInstance(args);
20354 }
20355
20356 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 PyObject *resultobj = 0;
20358 wxPNMHandler *result = 0 ;
20359
20360 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (wxPNMHandler *)new wxPNMHandler();
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *obj;
20376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20377 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20378 return SWIG_Py_Void();
20379 }
20380
20381 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20382 return SWIG_Python_InitShadowInstance(args);
20383 }
20384
20385 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxXPMHandler *result = 0 ;
20388
20389 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20390 {
20391 PyThreadState* __tstate = wxPyBeginAllowThreads();
20392 result = (wxXPMHandler *)new wxXPMHandler();
20393 wxPyEndAllowThreads(__tstate);
20394 if (PyErr_Occurred()) SWIG_fail;
20395 }
20396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *obj;
20405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20406 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20407 return SWIG_Py_Void();
20408 }
20409
20410 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 return SWIG_Python_InitShadowInstance(args);
20412 }
20413
20414 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 PyObject *resultobj = 0;
20416 wxTIFFHandler *result = 0 ;
20417
20418 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (wxTIFFHandler *)new wxTIFFHandler();
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *obj;
20434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20435 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20436 return SWIG_Py_Void();
20437 }
20438
20439 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20440 return SWIG_Python_InitShadowInstance(args);
20441 }
20442
20443 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj = 0;
20445 wxImage *arg1 = 0 ;
20446 wxImage *arg2 = 0 ;
20447 int arg3 = (int) 236 ;
20448 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20449 bool result;
20450 void *argp1 = 0 ;
20451 int res1 = 0 ;
20452 void *argp2 = 0 ;
20453 int res2 = 0 ;
20454 int val3 ;
20455 int ecode3 = 0 ;
20456 int val4 ;
20457 int ecode4 = 0 ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 PyObject * obj2 = 0 ;
20461 PyObject * obj3 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20464 };
20465
20466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20467 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20470 }
20471 if (!argp1) {
20472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20473 }
20474 arg1 = reinterpret_cast< wxImage * >(argp1);
20475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20476 if (!SWIG_IsOK(res2)) {
20477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20478 }
20479 if (!argp2) {
20480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20481 }
20482 arg2 = reinterpret_cast< wxImage * >(argp2);
20483 if (obj2) {
20484 ecode3 = SWIG_AsVal_int(obj2, &val3);
20485 if (!SWIG_IsOK(ecode3)) {
20486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20487 }
20488 arg3 = static_cast< int >(val3);
20489 }
20490 if (obj3) {
20491 ecode4 = SWIG_AsVal_int(obj3, &val4);
20492 if (!SWIG_IsOK(ecode4)) {
20493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20494 }
20495 arg4 = static_cast< int >(val4);
20496 }
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 {
20504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20505 }
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *obj;
20514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20515 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20516 return SWIG_Py_Void();
20517 }
20518
20519 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20520 PyObject *resultobj = 0;
20521 wxEvtHandler *result = 0 ;
20522
20523 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (wxEvtHandler *)new wxEvtHandler();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20540 wxEvtHandler *result = 0 ;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 PyObject *swig_obj[1] ;
20544
20545 if (!args) SWIG_fail;
20546 swig_obj[0] = args;
20547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20548 if (!SWIG_IsOK(res1)) {
20549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20550 }
20551 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 {
20559 resultobj = wxPyMake_wxObject(result, 0);
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20568 PyObject *resultobj = 0;
20569 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20570 wxEvtHandler *result = 0 ;
20571 void *argp1 = 0 ;
20572 int res1 = 0 ;
20573 PyObject *swig_obj[1] ;
20574
20575 if (!args) SWIG_fail;
20576 swig_obj[0] = args;
20577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20578 if (!SWIG_IsOK(res1)) {
20579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20580 }
20581 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 {
20589 resultobj = wxPyMake_wxObject(result, 0);
20590 }
20591 return resultobj;
20592 fail:
20593 return NULL;
20594 }
20595
20596
20597 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20598 PyObject *resultobj = 0;
20599 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20601 void *argp1 = 0 ;
20602 int res1 = 0 ;
20603 void *argp2 = 0 ;
20604 int res2 = 0 ;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char * kwnames[] = {
20608 (char *) "self",(char *) "handler", NULL
20609 };
20610
20611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20613 if (!SWIG_IsOK(res1)) {
20614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20615 }
20616 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20618 if (!SWIG_IsOK(res2)) {
20619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20620 }
20621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 (arg1)->SetNextHandler(arg2);
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 resultobj = SWIG_Py_Void();
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj = 0;
20637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20638 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20639 void *argp1 = 0 ;
20640 int res1 = 0 ;
20641 void *argp2 = 0 ;
20642 int res2 = 0 ;
20643 PyObject * obj0 = 0 ;
20644 PyObject * obj1 = 0 ;
20645 char * kwnames[] = {
20646 (char *) "self",(char *) "handler", NULL
20647 };
20648
20649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20651 if (!SWIG_IsOK(res1)) {
20652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20653 }
20654 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20656 if (!SWIG_IsOK(res2)) {
20657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20658 }
20659 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 (arg1)->SetPreviousHandler(arg2);
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 resultobj = SWIG_Py_Void();
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20674 PyObject *resultobj = 0;
20675 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20676 bool result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 PyObject *swig_obj[1] ;
20680
20681 if (!args) SWIG_fail;
20682 swig_obj[0] = args;
20683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20686 }
20687 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (bool)(arg1)->GetEvtHandlerEnabled();
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20696 }
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj = 0;
20705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20706 bool arg2 ;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 bool val2 ;
20710 int ecode2 = 0 ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 char * kwnames[] = {
20714 (char *) "self",(char *) "enabled", NULL
20715 };
20716
20717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20719 if (!SWIG_IsOK(res1)) {
20720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20721 }
20722 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20724 if (!SWIG_IsOK(ecode2)) {
20725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20726 }
20727 arg2 = static_cast< bool >(val2);
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 (arg1)->SetEvtHandlerEnabled(arg2);
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 resultobj = SWIG_Py_Void();
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20742 PyObject *resultobj = 0;
20743 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20744 wxEvent *arg2 = 0 ;
20745 bool result;
20746 void *argp1 = 0 ;
20747 int res1 = 0 ;
20748 void *argp2 = 0 ;
20749 int res2 = 0 ;
20750 PyObject * obj0 = 0 ;
20751 PyObject * obj1 = 0 ;
20752 char * kwnames[] = {
20753 (char *) "self",(char *) "event", NULL
20754 };
20755
20756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20758 if (!SWIG_IsOK(res1)) {
20759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20760 }
20761 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20763 if (!SWIG_IsOK(res2)) {
20764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20765 }
20766 if (!argp2) {
20767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20768 }
20769 arg2 = reinterpret_cast< wxEvent * >(argp2);
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (bool)(arg1)->ProcessEvent(*arg2);
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj = 0;
20787 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20788 wxEvent *arg2 = 0 ;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 void *argp2 = 0 ;
20792 int res2 = 0 ;
20793 PyObject * obj0 = 0 ;
20794 PyObject * obj1 = 0 ;
20795 char * kwnames[] = {
20796 (char *) "self",(char *) "event", NULL
20797 };
20798
20799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20803 }
20804 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20806 if (!SWIG_IsOK(res2)) {
20807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20808 }
20809 if (!argp2) {
20810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20811 }
20812 arg2 = reinterpret_cast< wxEvent * >(argp2);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 (arg1)->AddPendingEvent(*arg2);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_Py_Void();
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 PyObject *swig_obj[1] ;
20832
20833 if (!args) SWIG_fail;
20834 swig_obj[0] = args;
20835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20838 }
20839 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 (arg1)->ProcessPendingEvents();
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = SWIG_Py_Void();
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20854 PyObject *resultobj = 0;
20855 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20856 bool arg2 = (bool) true ;
20857 void *argp1 = 0 ;
20858 int res1 = 0 ;
20859 bool val2 ;
20860 int ecode2 = 0 ;
20861 PyObject * obj0 = 0 ;
20862 PyObject * obj1 = 0 ;
20863 char * kwnames[] = {
20864 (char *) "self",(char *) "allow", NULL
20865 };
20866
20867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20871 }
20872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20873 if (obj1) {
20874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20875 if (!SWIG_IsOK(ecode2)) {
20876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20877 }
20878 arg2 = static_cast< bool >(val2);
20879 }
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 (arg1)->AllowReentrance(arg2);
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 resultobj = SWIG_Py_Void();
20887 return resultobj;
20888 fail:
20889 return NULL;
20890 }
20891
20892
20893 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20894 PyObject *resultobj = 0;
20895 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20896 bool result;
20897 void *argp1 = 0 ;
20898 int res1 = 0 ;
20899 PyObject *swig_obj[1] ;
20900
20901 if (!args) SWIG_fail;
20902 swig_obj[0] = args;
20903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20904 if (!SWIG_IsOK(res1)) {
20905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20906 }
20907 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (bool)(arg1)->IsReentranceAllowed();
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 {
20915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20916 }
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20924 PyObject *resultobj = 0;
20925 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20926 bool result;
20927 void *argp1 = 0 ;
20928 int res1 = 0 ;
20929 PyObject *swig_obj[1] ;
20930
20931 if (!args) SWIG_fail;
20932 swig_obj[0] = args;
20933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20934 if (!SWIG_IsOK(res1)) {
20935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20936 }
20937 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 result = (bool)(arg1)->IsEventHandlingInProgress();
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 {
20945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20946 }
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20954 PyObject *resultobj = 0;
20955 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20956 int arg2 ;
20957 int arg3 ;
20958 int arg4 ;
20959 PyObject *arg5 = (PyObject *) 0 ;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 int val2 ;
20963 int ecode2 = 0 ;
20964 int val3 ;
20965 int ecode3 = 0 ;
20966 int val4 ;
20967 int ecode4 = 0 ;
20968 PyObject * obj0 = 0 ;
20969 PyObject * obj1 = 0 ;
20970 PyObject * obj2 = 0 ;
20971 PyObject * obj3 = 0 ;
20972 PyObject * obj4 = 0 ;
20973 char * kwnames[] = {
20974 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20975 };
20976
20977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20979 if (!SWIG_IsOK(res1)) {
20980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20981 }
20982 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20983 ecode2 = SWIG_AsVal_int(obj1, &val2);
20984 if (!SWIG_IsOK(ecode2)) {
20985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20986 }
20987 arg2 = static_cast< int >(val2);
20988 ecode3 = SWIG_AsVal_int(obj2, &val3);
20989 if (!SWIG_IsOK(ecode3)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20991 }
20992 arg3 = static_cast< int >(val3);
20993 ecode4 = SWIG_AsVal_int(obj3, &val4);
20994 if (!SWIG_IsOK(ecode4)) {
20995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20996 }
20997 arg4 = static_cast< int >(val4);
20998 arg5 = obj4;
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 resultobj = SWIG_Py_Void();
21006 return resultobj;
21007 fail:
21008 return NULL;
21009 }
21010
21011
21012 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21013 PyObject *resultobj = 0;
21014 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21015 int arg2 ;
21016 int arg3 = (int) -1 ;
21017 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21018 bool result;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 int val2 ;
21022 int ecode2 = 0 ;
21023 int val3 ;
21024 int ecode3 = 0 ;
21025 int val4 ;
21026 int ecode4 = 0 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 PyObject * obj2 = 0 ;
21030 PyObject * obj3 = 0 ;
21031 char * kwnames[] = {
21032 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21033 };
21034
21035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21037 if (!SWIG_IsOK(res1)) {
21038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21039 }
21040 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21041 ecode2 = SWIG_AsVal_int(obj1, &val2);
21042 if (!SWIG_IsOK(ecode2)) {
21043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21044 }
21045 arg2 = static_cast< int >(val2);
21046 if (obj2) {
21047 ecode3 = SWIG_AsVal_int(obj2, &val3);
21048 if (!SWIG_IsOK(ecode3)) {
21049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21050 }
21051 arg3 = static_cast< int >(val3);
21052 }
21053 if (obj3) {
21054 ecode4 = SWIG_AsVal_int(obj3, &val4);
21055 if (!SWIG_IsOK(ecode4)) {
21056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21057 }
21058 arg4 = static_cast< wxEventType >(val4);
21059 }
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21068 }
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21076 PyObject *resultobj = 0;
21077 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21078 PyObject *arg2 = (PyObject *) 0 ;
21079 bool arg3 = (bool) true ;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 bool val3 ;
21083 int ecode3 = 0 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 PyObject * obj2 = 0 ;
21087 char * kwnames[] = {
21088 (char *) "self",(char *) "_self",(char *) "incref", NULL
21089 };
21090
21091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21093 if (!SWIG_IsOK(res1)) {
21094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21095 }
21096 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21097 arg2 = obj1;
21098 if (obj2) {
21099 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21100 if (!SWIG_IsOK(ecode3)) {
21101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21102 }
21103 arg3 = static_cast< bool >(val3);
21104 }
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 resultobj = SWIG_Py_Void();
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *obj;
21120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21121 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21122 return SWIG_Py_Void();
21123 }
21124
21125 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21126 return SWIG_Python_InitShadowInstance(args);
21127 }
21128
21129 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxEventType result;
21132
21133 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (wxEventType)wxNewEventType();
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_From_int(static_cast< int >(result));
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxEvent *arg1 = (wxEvent *) 0 ;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21159 }
21160 arg1 = reinterpret_cast< wxEvent * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 delete arg1;
21164
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 resultobj = SWIG_Py_Void();
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21176 PyObject *resultobj = 0;
21177 wxEvent *arg1 = (wxEvent *) 0 ;
21178 wxEventType arg2 ;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 int val2 ;
21182 int ecode2 = 0 ;
21183 PyObject * obj0 = 0 ;
21184 PyObject * obj1 = 0 ;
21185 char * kwnames[] = {
21186 (char *) "self",(char *) "typ", NULL
21187 };
21188
21189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21191 if (!SWIG_IsOK(res1)) {
21192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21193 }
21194 arg1 = reinterpret_cast< wxEvent * >(argp1);
21195 ecode2 = SWIG_AsVal_int(obj1, &val2);
21196 if (!SWIG_IsOK(ecode2)) {
21197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21198 }
21199 arg2 = static_cast< wxEventType >(val2);
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 (arg1)->SetEventType(arg2);
21203 wxPyEndAllowThreads(__tstate);
21204 if (PyErr_Occurred()) SWIG_fail;
21205 }
21206 resultobj = SWIG_Py_Void();
21207 return resultobj;
21208 fail:
21209 return NULL;
21210 }
21211
21212
21213 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21214 PyObject *resultobj = 0;
21215 wxEvent *arg1 = (wxEvent *) 0 ;
21216 wxEventType result;
21217 void *argp1 = 0 ;
21218 int res1 = 0 ;
21219 PyObject *swig_obj[1] ;
21220
21221 if (!args) SWIG_fail;
21222 swig_obj[0] = args;
21223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21226 }
21227 arg1 = reinterpret_cast< wxEvent * >(argp1);
21228 {
21229 PyThreadState* __tstate = wxPyBeginAllowThreads();
21230 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21231 wxPyEndAllowThreads(__tstate);
21232 if (PyErr_Occurred()) SWIG_fail;
21233 }
21234 resultobj = SWIG_From_int(static_cast< int >(result));
21235 return resultobj;
21236 fail:
21237 return NULL;
21238 }
21239
21240
21241 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21242 PyObject *resultobj = 0;
21243 wxEvent *arg1 = (wxEvent *) 0 ;
21244 wxObject *result = 0 ;
21245 void *argp1 = 0 ;
21246 int res1 = 0 ;
21247 PyObject *swig_obj[1] ;
21248
21249 if (!args) SWIG_fail;
21250 swig_obj[0] = args;
21251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21252 if (!SWIG_IsOK(res1)) {
21253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21254 }
21255 arg1 = reinterpret_cast< wxEvent * >(argp1);
21256 {
21257 PyThreadState* __tstate = wxPyBeginAllowThreads();
21258 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21259 wxPyEndAllowThreads(__tstate);
21260 if (PyErr_Occurred()) SWIG_fail;
21261 }
21262 {
21263 resultobj = wxPyMake_wxObject(result, (bool)0);
21264 }
21265 return resultobj;
21266 fail:
21267 return NULL;
21268 }
21269
21270
21271 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj = 0;
21273 wxEvent *arg1 = (wxEvent *) 0 ;
21274 wxObject *arg2 = (wxObject *) 0 ;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 void *argp2 = 0 ;
21278 int res2 = 0 ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char * kwnames[] = {
21282 (char *) "self",(char *) "obj", NULL
21283 };
21284
21285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21289 }
21290 arg1 = reinterpret_cast< wxEvent * >(argp1);
21291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21292 if (!SWIG_IsOK(res2)) {
21293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21294 }
21295 arg2 = reinterpret_cast< wxObject * >(argp2);
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 (arg1)->SetEventObject(arg2);
21299 wxPyEndAllowThreads(__tstate);
21300 if (PyErr_Occurred()) SWIG_fail;
21301 }
21302 resultobj = SWIG_Py_Void();
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21310 PyObject *resultobj = 0;
21311 wxEvent *arg1 = (wxEvent *) 0 ;
21312 long result;
21313 void *argp1 = 0 ;
21314 int res1 = 0 ;
21315 PyObject *swig_obj[1] ;
21316
21317 if (!args) SWIG_fail;
21318 swig_obj[0] = args;
21319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21322 }
21323 arg1 = reinterpret_cast< wxEvent * >(argp1);
21324 {
21325 PyThreadState* __tstate = wxPyBeginAllowThreads();
21326 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21327 wxPyEndAllowThreads(__tstate);
21328 if (PyErr_Occurred()) SWIG_fail;
21329 }
21330 resultobj = SWIG_From_long(static_cast< long >(result));
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21338 PyObject *resultobj = 0;
21339 wxEvent *arg1 = (wxEvent *) 0 ;
21340 long arg2 = (long) 0 ;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 long val2 ;
21344 int ecode2 = 0 ;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 char * kwnames[] = {
21348 (char *) "self",(char *) "ts", NULL
21349 };
21350
21351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21355 }
21356 arg1 = reinterpret_cast< wxEvent * >(argp1);
21357 if (obj1) {
21358 ecode2 = SWIG_AsVal_long(obj1, &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21361 }
21362 arg2 = static_cast< long >(val2);
21363 }
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 (arg1)->SetTimestamp(arg2);
21367 wxPyEndAllowThreads(__tstate);
21368 if (PyErr_Occurred()) SWIG_fail;
21369 }
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxEvent *arg1 = (wxEvent *) 0 ;
21380 int result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxEvent * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (int)((wxEvent const *)arg1)->GetId();
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 resultobj = SWIG_From_int(static_cast< int >(result));
21399 return resultobj;
21400 fail:
21401 return NULL;
21402 }
21403
21404
21405 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21406 PyObject *resultobj = 0;
21407 wxEvent *arg1 = (wxEvent *) 0 ;
21408 int arg2 ;
21409 void *argp1 = 0 ;
21410 int res1 = 0 ;
21411 int val2 ;
21412 int ecode2 = 0 ;
21413 PyObject * obj0 = 0 ;
21414 PyObject * obj1 = 0 ;
21415 char * kwnames[] = {
21416 (char *) "self",(char *) "Id", NULL
21417 };
21418
21419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21421 if (!SWIG_IsOK(res1)) {
21422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21423 }
21424 arg1 = reinterpret_cast< wxEvent * >(argp1);
21425 ecode2 = SWIG_AsVal_int(obj1, &val2);
21426 if (!SWIG_IsOK(ecode2)) {
21427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21428 }
21429 arg2 = static_cast< int >(val2);
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 (arg1)->SetId(arg2);
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 resultobj = SWIG_Py_Void();
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21444 PyObject *resultobj = 0;
21445 wxEvent *arg1 = (wxEvent *) 0 ;
21446 bool result;
21447 void *argp1 = 0 ;
21448 int res1 = 0 ;
21449 PyObject *swig_obj[1] ;
21450
21451 if (!args) SWIG_fail;
21452 swig_obj[0] = args;
21453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21456 }
21457 arg1 = reinterpret_cast< wxEvent * >(argp1);
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21461 wxPyEndAllowThreads(__tstate);
21462 if (PyErr_Occurred()) SWIG_fail;
21463 }
21464 {
21465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21474 PyObject *resultobj = 0;
21475 wxEvent *arg1 = (wxEvent *) 0 ;
21476 bool arg2 = (bool) true ;
21477 void *argp1 = 0 ;
21478 int res1 = 0 ;
21479 bool val2 ;
21480 int ecode2 = 0 ;
21481 PyObject * obj0 = 0 ;
21482 PyObject * obj1 = 0 ;
21483 char * kwnames[] = {
21484 (char *) "self",(char *) "skip", NULL
21485 };
21486
21487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21489 if (!SWIG_IsOK(res1)) {
21490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21491 }
21492 arg1 = reinterpret_cast< wxEvent * >(argp1);
21493 if (obj1) {
21494 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21495 if (!SWIG_IsOK(ecode2)) {
21496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21497 }
21498 arg2 = static_cast< bool >(val2);
21499 }
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 (arg1)->Skip(arg2);
21503 wxPyEndAllowThreads(__tstate);
21504 if (PyErr_Occurred()) SWIG_fail;
21505 }
21506 resultobj = SWIG_Py_Void();
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21514 PyObject *resultobj = 0;
21515 wxEvent *arg1 = (wxEvent *) 0 ;
21516 bool result;
21517 void *argp1 = 0 ;
21518 int res1 = 0 ;
21519 PyObject *swig_obj[1] ;
21520
21521 if (!args) SWIG_fail;
21522 swig_obj[0] = args;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21526 }
21527 arg1 = reinterpret_cast< wxEvent * >(argp1);
21528 {
21529 PyThreadState* __tstate = wxPyBeginAllowThreads();
21530 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21531 wxPyEndAllowThreads(__tstate);
21532 if (PyErr_Occurred()) SWIG_fail;
21533 }
21534 {
21535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21536 }
21537 return resultobj;
21538 fail:
21539 return NULL;
21540 }
21541
21542
21543 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21544 PyObject *resultobj = 0;
21545 wxEvent *arg1 = (wxEvent *) 0 ;
21546 bool result;
21547 void *argp1 = 0 ;
21548 int res1 = 0 ;
21549 PyObject *swig_obj[1] ;
21550
21551 if (!args) SWIG_fail;
21552 swig_obj[0] = args;
21553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21554 if (!SWIG_IsOK(res1)) {
21555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21556 }
21557 arg1 = reinterpret_cast< wxEvent * >(argp1);
21558 {
21559 PyThreadState* __tstate = wxPyBeginAllowThreads();
21560 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21561 wxPyEndAllowThreads(__tstate);
21562 if (PyErr_Occurred()) SWIG_fail;
21563 }
21564 {
21565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21566 }
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxEvent *arg1 = (wxEvent *) 0 ;
21576 int result;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (int)(arg1)->StopPropagation();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_From_int(static_cast< int >(result));
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21602 PyObject *resultobj = 0;
21603 wxEvent *arg1 = (wxEvent *) 0 ;
21604 int arg2 ;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 int val2 ;
21608 int ecode2 = 0 ;
21609 PyObject * obj0 = 0 ;
21610 PyObject * obj1 = 0 ;
21611 char * kwnames[] = {
21612 (char *) "self",(char *) "propagationLevel", NULL
21613 };
21614
21615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21619 }
21620 arg1 = reinterpret_cast< wxEvent * >(argp1);
21621 ecode2 = SWIG_AsVal_int(obj1, &val2);
21622 if (!SWIG_IsOK(ecode2)) {
21623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21624 }
21625 arg2 = static_cast< int >(val2);
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 (arg1)->ResumePropagation(arg2);
21629 wxPyEndAllowThreads(__tstate);
21630 if (PyErr_Occurred()) SWIG_fail;
21631 }
21632 resultobj = SWIG_Py_Void();
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21640 PyObject *resultobj = 0;
21641 wxEvent *arg1 = (wxEvent *) 0 ;
21642 wxEvent *result = 0 ;
21643 void *argp1 = 0 ;
21644 int res1 = 0 ;
21645 PyObject *swig_obj[1] ;
21646
21647 if (!args) SWIG_fail;
21648 swig_obj[0] = args;
21649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21650 if (!SWIG_IsOK(res1)) {
21651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21652 }
21653 arg1 = reinterpret_cast< wxEvent * >(argp1);
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 result = (wxEvent *)(arg1)->Clone();
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *obj;
21669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21670 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21671 return SWIG_Py_Void();
21672 }
21673
21674 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21675 PyObject *resultobj = 0;
21676 wxEvent *arg1 = 0 ;
21677 wxPropagationDisabler *result = 0 ;
21678 void *argp1 = 0 ;
21679 int res1 = 0 ;
21680 PyObject * obj0 = 0 ;
21681 char * kwnames[] = {
21682 (char *) "event", NULL
21683 };
21684
21685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21686 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21687 if (!SWIG_IsOK(res1)) {
21688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21689 }
21690 if (!argp1) {
21691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21692 }
21693 arg1 = reinterpret_cast< wxEvent * >(argp1);
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21697 wxPyEndAllowThreads(__tstate);
21698 if (PyErr_Occurred()) SWIG_fail;
21699 }
21700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21701 return resultobj;
21702 fail:
21703 return NULL;
21704 }
21705
21706
21707 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21708 PyObject *resultobj = 0;
21709 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21710 void *argp1 = 0 ;
21711 int res1 = 0 ;
21712 PyObject *swig_obj[1] ;
21713
21714 if (!args) SWIG_fail;
21715 swig_obj[0] = args;
21716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21717 if (!SWIG_IsOK(res1)) {
21718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21719 }
21720 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 delete arg1;
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 resultobj = SWIG_Py_Void();
21729 return resultobj;
21730 fail:
21731 return NULL;
21732 }
21733
21734
21735 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21736 PyObject *obj;
21737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21738 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21739 return SWIG_Py_Void();
21740 }
21741
21742 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21743 return SWIG_Python_InitShadowInstance(args);
21744 }
21745
21746 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj = 0;
21748 wxEvent *arg1 = 0 ;
21749 wxPropagateOnce *result = 0 ;
21750 void *argp1 = 0 ;
21751 int res1 = 0 ;
21752 PyObject * obj0 = 0 ;
21753 char * kwnames[] = {
21754 (char *) "event", NULL
21755 };
21756
21757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21758 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21759 if (!SWIG_IsOK(res1)) {
21760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21761 }
21762 if (!argp1) {
21763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21764 }
21765 arg1 = reinterpret_cast< wxEvent * >(argp1);
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21782 void *argp1 = 0 ;
21783 int res1 = 0 ;
21784 PyObject *swig_obj[1] ;
21785
21786 if (!args) SWIG_fail;
21787 swig_obj[0] = args;
21788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21789 if (!SWIG_IsOK(res1)) {
21790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21791 }
21792 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21793 {
21794 PyThreadState* __tstate = wxPyBeginAllowThreads();
21795 delete arg1;
21796
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 resultobj = SWIG_Py_Void();
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21808 PyObject *obj;
21809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21810 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21811 return SWIG_Py_Void();
21812 }
21813
21814 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21815 return SWIG_Python_InitShadowInstance(args);
21816 }
21817
21818 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21819 PyObject *resultobj = 0;
21820 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21821 int arg2 = (int) 0 ;
21822 wxCommandEvent *result = 0 ;
21823 int val1 ;
21824 int ecode1 = 0 ;
21825 int val2 ;
21826 int ecode2 = 0 ;
21827 PyObject * obj0 = 0 ;
21828 PyObject * obj1 = 0 ;
21829 char * kwnames[] = {
21830 (char *) "commandType",(char *) "winid", NULL
21831 };
21832
21833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21834 if (obj0) {
21835 ecode1 = SWIG_AsVal_int(obj0, &val1);
21836 if (!SWIG_IsOK(ecode1)) {
21837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21838 }
21839 arg1 = static_cast< wxEventType >(val1);
21840 }
21841 if (obj1) {
21842 ecode2 = SWIG_AsVal_int(obj1, &val2);
21843 if (!SWIG_IsOK(ecode2)) {
21844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21845 }
21846 arg2 = static_cast< int >(val2);
21847 }
21848 {
21849 PyThreadState* __tstate = wxPyBeginAllowThreads();
21850 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21862 PyObject *resultobj = 0;
21863 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21864 int result;
21865 void *argp1 = 0 ;
21866 int res1 = 0 ;
21867 PyObject *swig_obj[1] ;
21868
21869 if (!args) SWIG_fail;
21870 swig_obj[0] = args;
21871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21872 if (!SWIG_IsOK(res1)) {
21873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21874 }
21875 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 resultobj = SWIG_From_int(static_cast< int >(result));
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj = 0;
21891 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21892 wxString *arg2 = 0 ;
21893 void *argp1 = 0 ;
21894 int res1 = 0 ;
21895 bool temp2 = false ;
21896 PyObject * obj0 = 0 ;
21897 PyObject * obj1 = 0 ;
21898 char * kwnames[] = {
21899 (char *) "self",(char *) "s", NULL
21900 };
21901
21902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21904 if (!SWIG_IsOK(res1)) {
21905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21906 }
21907 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21908 {
21909 arg2 = wxString_in_helper(obj1);
21910 if (arg2 == NULL) SWIG_fail;
21911 temp2 = true;
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 (arg1)->SetString((wxString const &)*arg2);
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 resultobj = SWIG_Py_Void();
21920 {
21921 if (temp2)
21922 delete arg2;
21923 }
21924 return resultobj;
21925 fail:
21926 {
21927 if (temp2)
21928 delete arg2;
21929 }
21930 return NULL;
21931 }
21932
21933
21934 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21935 PyObject *resultobj = 0;
21936 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21937 wxString result;
21938 void *argp1 = 0 ;
21939 int res1 = 0 ;
21940 PyObject *swig_obj[1] ;
21941
21942 if (!args) SWIG_fail;
21943 swig_obj[0] = args;
21944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21945 if (!SWIG_IsOK(res1)) {
21946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21947 }
21948 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = ((wxCommandEvent const *)arg1)->GetString();
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 #if wxUSE_UNICODE
21957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21958 #else
21959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21960 #endif
21961 }
21962 return resultobj;
21963 fail:
21964 return NULL;
21965 }
21966
21967
21968 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21969 PyObject *resultobj = 0;
21970 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21971 bool result;
21972 void *argp1 = 0 ;
21973 int res1 = 0 ;
21974 PyObject *swig_obj[1] ;
21975
21976 if (!args) SWIG_fail;
21977 swig_obj[0] = args;
21978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21979 if (!SWIG_IsOK(res1)) {
21980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21981 }
21982 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21986 wxPyEndAllowThreads(__tstate);
21987 if (PyErr_Occurred()) SWIG_fail;
21988 }
21989 {
21990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21991 }
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22001 bool result;
22002 void *argp1 = 0 ;
22003 int res1 = 0 ;
22004 PyObject *swig_obj[1] ;
22005
22006 if (!args) SWIG_fail;
22007 swig_obj[0] = args;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22011 }
22012 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 {
22020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22021 }
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj = 0;
22030 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22031 long arg2 ;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 long val2 ;
22035 int ecode2 = 0 ;
22036 PyObject * obj0 = 0 ;
22037 PyObject * obj1 = 0 ;
22038 char * kwnames[] = {
22039 (char *) "self",(char *) "extraLong", NULL
22040 };
22041
22042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22046 }
22047 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22048 ecode2 = SWIG_AsVal_long(obj1, &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22051 }
22052 arg2 = static_cast< long >(val2);
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->SetExtraLong(arg2);
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22069 long result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 resultobj = SWIG_From_long(static_cast< long >(result));
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22095 PyObject *resultobj = 0;
22096 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22097 int arg2 ;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 int val2 ;
22101 int ecode2 = 0 ;
22102 PyObject * obj0 = 0 ;
22103 PyObject * obj1 = 0 ;
22104 char * kwnames[] = {
22105 (char *) "self",(char *) "i", NULL
22106 };
22107
22108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22112 }
22113 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22114 ecode2 = SWIG_AsVal_int(obj1, &val2);
22115 if (!SWIG_IsOK(ecode2)) {
22116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22117 }
22118 arg2 = static_cast< int >(val2);
22119 {
22120 PyThreadState* __tstate = wxPyBeginAllowThreads();
22121 (arg1)->SetInt(arg2);
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 resultobj = SWIG_Py_Void();
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22133 PyObject *resultobj = 0;
22134 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22135 int result;
22136 void *argp1 = 0 ;
22137 int res1 = 0 ;
22138 PyObject *swig_obj[1] ;
22139
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22145 }
22146 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 resultobj = SWIG_From_int(static_cast< int >(result));
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 PyObject *resultobj = 0;
22162 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22163 PyObject *result = 0 ;
22164 void *argp1 = 0 ;
22165 int res1 = 0 ;
22166 PyObject *swig_obj[1] ;
22167
22168 if (!args) SWIG_fail;
22169 swig_obj[0] = args;
22170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22173 }
22174 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22178 wxPyEndAllowThreads(__tstate);
22179 if (PyErr_Occurred()) SWIG_fail;
22180 }
22181 resultobj = result;
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj = 0;
22190 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22191 PyObject *arg2 = (PyObject *) 0 ;
22192 void *argp1 = 0 ;
22193 int res1 = 0 ;
22194 PyObject * obj0 = 0 ;
22195 PyObject * obj1 = 0 ;
22196 char * kwnames[] = {
22197 (char *) "self",(char *) "clientData", NULL
22198 };
22199
22200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22202 if (!SWIG_IsOK(res1)) {
22203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22204 }
22205 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22206 arg2 = obj1;
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 wxCommandEvent_SetClientData(arg1,arg2);
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_Py_Void();
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22223 wxEvent *result = 0 ;
22224 void *argp1 = 0 ;
22225 int res1 = 0 ;
22226 PyObject *swig_obj[1] ;
22227
22228 if (!args) SWIG_fail;
22229 swig_obj[0] = args;
22230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22231 if (!SWIG_IsOK(res1)) {
22232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22233 }
22234 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22235 {
22236 PyThreadState* __tstate = wxPyBeginAllowThreads();
22237 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22249 PyObject *obj;
22250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22251 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22252 return SWIG_Py_Void();
22253 }
22254
22255 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22256 return SWIG_Python_InitShadowInstance(args);
22257 }
22258
22259 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22260 PyObject *resultobj = 0;
22261 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22262 int arg2 = (int) 0 ;
22263 wxNotifyEvent *result = 0 ;
22264 int val1 ;
22265 int ecode1 = 0 ;
22266 int val2 ;
22267 int ecode2 = 0 ;
22268 PyObject * obj0 = 0 ;
22269 PyObject * obj1 = 0 ;
22270 char * kwnames[] = {
22271 (char *) "commandType",(char *) "winid", NULL
22272 };
22273
22274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22275 if (obj0) {
22276 ecode1 = SWIG_AsVal_int(obj0, &val1);
22277 if (!SWIG_IsOK(ecode1)) {
22278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22279 }
22280 arg1 = static_cast< wxEventType >(val1);
22281 }
22282 if (obj1) {
22283 ecode2 = SWIG_AsVal_int(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22286 }
22287 arg2 = static_cast< int >(val2);
22288 }
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *resultobj = 0;
22304 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22314 }
22315 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 (arg1)->Veto();
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 resultobj = SWIG_Py_Void();
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22341 }
22342 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 (arg1)->Allow();
22346 wxPyEndAllowThreads(__tstate);
22347 if (PyErr_Occurred()) SWIG_fail;
22348 }
22349 resultobj = SWIG_Py_Void();
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 PyObject *resultobj = 0;
22358 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22359 bool result;
22360 void *argp1 = 0 ;
22361 int res1 = 0 ;
22362 PyObject *swig_obj[1] ;
22363
22364 if (!args) SWIG_fail;
22365 swig_obj[0] = args;
22366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22367 if (!SWIG_IsOK(res1)) {
22368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22369 }
22370 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22371 {
22372 PyThreadState* __tstate = wxPyBeginAllowThreads();
22373 result = (bool)(arg1)->IsAllowed();
22374 wxPyEndAllowThreads(__tstate);
22375 if (PyErr_Occurred()) SWIG_fail;
22376 }
22377 {
22378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22379 }
22380 return resultobj;
22381 fail:
22382 return NULL;
22383 }
22384
22385
22386 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22387 PyObject *obj;
22388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22389 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22390 return SWIG_Py_Void();
22391 }
22392
22393 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22394 return SWIG_Python_InitShadowInstance(args);
22395 }
22396
22397 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22398 PyObject *resultobj = 0;
22399 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22400 int arg2 = (int) 0 ;
22401 int arg3 = (int) 0 ;
22402 int arg4 = (int) 0 ;
22403 wxScrollEvent *result = 0 ;
22404 int val1 ;
22405 int ecode1 = 0 ;
22406 int val2 ;
22407 int ecode2 = 0 ;
22408 int val3 ;
22409 int ecode3 = 0 ;
22410 int val4 ;
22411 int ecode4 = 0 ;
22412 PyObject * obj0 = 0 ;
22413 PyObject * obj1 = 0 ;
22414 PyObject * obj2 = 0 ;
22415 PyObject * obj3 = 0 ;
22416 char * kwnames[] = {
22417 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22418 };
22419
22420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22421 if (obj0) {
22422 ecode1 = SWIG_AsVal_int(obj0, &val1);
22423 if (!SWIG_IsOK(ecode1)) {
22424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22425 }
22426 arg1 = static_cast< wxEventType >(val1);
22427 }
22428 if (obj1) {
22429 ecode2 = SWIG_AsVal_int(obj1, &val2);
22430 if (!SWIG_IsOK(ecode2)) {
22431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22432 }
22433 arg2 = static_cast< int >(val2);
22434 }
22435 if (obj2) {
22436 ecode3 = SWIG_AsVal_int(obj2, &val3);
22437 if (!SWIG_IsOK(ecode3)) {
22438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22439 }
22440 arg3 = static_cast< int >(val3);
22441 }
22442 if (obj3) {
22443 ecode4 = SWIG_AsVal_int(obj3, &val4);
22444 if (!SWIG_IsOK(ecode4)) {
22445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22446 }
22447 arg4 = static_cast< int >(val4);
22448 }
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22456 return resultobj;
22457 fail:
22458 return NULL;
22459 }
22460
22461
22462 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22463 PyObject *resultobj = 0;
22464 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22465 int result;
22466 void *argp1 = 0 ;
22467 int res1 = 0 ;
22468 PyObject *swig_obj[1] ;
22469
22470 if (!args) SWIG_fail;
22471 swig_obj[0] = args;
22472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22473 if (!SWIG_IsOK(res1)) {
22474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22475 }
22476 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_From_int(static_cast< int >(result));
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22491 PyObject *resultobj = 0;
22492 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22493 int result;
22494 void *argp1 = 0 ;
22495 int res1 = 0 ;
22496 PyObject *swig_obj[1] ;
22497
22498 if (!args) SWIG_fail;
22499 swig_obj[0] = args;
22500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22501 if (!SWIG_IsOK(res1)) {
22502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22503 }
22504 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22505 {
22506 PyThreadState* __tstate = wxPyBeginAllowThreads();
22507 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22508 wxPyEndAllowThreads(__tstate);
22509 if (PyErr_Occurred()) SWIG_fail;
22510 }
22511 resultobj = SWIG_From_int(static_cast< int >(result));
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22519 PyObject *resultobj = 0;
22520 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22521 int arg2 ;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 int val2 ;
22525 int ecode2 = 0 ;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char * kwnames[] = {
22529 (char *) "self",(char *) "orient", NULL
22530 };
22531
22532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22536 }
22537 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22538 ecode2 = SWIG_AsVal_int(obj1, &val2);
22539 if (!SWIG_IsOK(ecode2)) {
22540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22541 }
22542 arg2 = static_cast< int >(val2);
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 (arg1)->SetOrientation(arg2);
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_Py_Void();
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj = 0;
22558 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22559 int arg2 ;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 int val2 ;
22563 int ecode2 = 0 ;
22564 PyObject * obj0 = 0 ;
22565 PyObject * obj1 = 0 ;
22566 char * kwnames[] = {
22567 (char *) "self",(char *) "pos", NULL
22568 };
22569
22570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22572 if (!SWIG_IsOK(res1)) {
22573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22574 }
22575 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22576 ecode2 = SWIG_AsVal_int(obj1, &val2);
22577 if (!SWIG_IsOK(ecode2)) {
22578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22579 }
22580 arg2 = static_cast< int >(val2);
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 (arg1)->SetPosition(arg2);
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 resultobj = SWIG_Py_Void();
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *obj;
22596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22597 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22598 return SWIG_Py_Void();
22599 }
22600
22601 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22602 return SWIG_Python_InitShadowInstance(args);
22603 }
22604
22605 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22606 PyObject *resultobj = 0;
22607 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22608 int arg2 = (int) 0 ;
22609 int arg3 = (int) 0 ;
22610 wxScrollWinEvent *result = 0 ;
22611 int val1 ;
22612 int ecode1 = 0 ;
22613 int val2 ;
22614 int ecode2 = 0 ;
22615 int val3 ;
22616 int ecode3 = 0 ;
22617 PyObject * obj0 = 0 ;
22618 PyObject * obj1 = 0 ;
22619 PyObject * obj2 = 0 ;
22620 char * kwnames[] = {
22621 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22622 };
22623
22624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22625 if (obj0) {
22626 ecode1 = SWIG_AsVal_int(obj0, &val1);
22627 if (!SWIG_IsOK(ecode1)) {
22628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22629 }
22630 arg1 = static_cast< wxEventType >(val1);
22631 }
22632 if (obj1) {
22633 ecode2 = SWIG_AsVal_int(obj1, &val2);
22634 if (!SWIG_IsOK(ecode2)) {
22635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22636 }
22637 arg2 = static_cast< int >(val2);
22638 }
22639 if (obj2) {
22640 ecode3 = SWIG_AsVal_int(obj2, &val3);
22641 if (!SWIG_IsOK(ecode3)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22643 }
22644 arg3 = static_cast< int >(val3);
22645 }
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22649 wxPyEndAllowThreads(__tstate);
22650 if (PyErr_Occurred()) SWIG_fail;
22651 }
22652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660 PyObject *resultobj = 0;
22661 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22662 int result;
22663 void *argp1 = 0 ;
22664 int res1 = 0 ;
22665 PyObject *swig_obj[1] ;
22666
22667 if (!args) SWIG_fail;
22668 swig_obj[0] = args;
22669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22670 if (!SWIG_IsOK(res1)) {
22671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22672 }
22673 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 resultobj = SWIG_From_int(static_cast< int >(result));
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 PyObject *resultobj = 0;
22689 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22690 int result;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 PyObject *swig_obj[1] ;
22694
22695 if (!args) SWIG_fail;
22696 swig_obj[0] = args;
22697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22698 if (!SWIG_IsOK(res1)) {
22699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22700 }
22701 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22702 {
22703 PyThreadState* __tstate = wxPyBeginAllowThreads();
22704 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22705 wxPyEndAllowThreads(__tstate);
22706 if (PyErr_Occurred()) SWIG_fail;
22707 }
22708 resultobj = SWIG_From_int(static_cast< int >(result));
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22716 PyObject *resultobj = 0;
22717 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22718 int arg2 ;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 int val2 ;
22722 int ecode2 = 0 ;
22723 PyObject * obj0 = 0 ;
22724 PyObject * obj1 = 0 ;
22725 char * kwnames[] = {
22726 (char *) "self",(char *) "orient", NULL
22727 };
22728
22729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22731 if (!SWIG_IsOK(res1)) {
22732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22733 }
22734 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22735 ecode2 = SWIG_AsVal_int(obj1, &val2);
22736 if (!SWIG_IsOK(ecode2)) {
22737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22738 }
22739 arg2 = static_cast< int >(val2);
22740 {
22741 PyThreadState* __tstate = wxPyBeginAllowThreads();
22742 (arg1)->SetOrientation(arg2);
22743 wxPyEndAllowThreads(__tstate);
22744 if (PyErr_Occurred()) SWIG_fail;
22745 }
22746 resultobj = SWIG_Py_Void();
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22754 PyObject *resultobj = 0;
22755 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22756 int arg2 ;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 int val2 ;
22760 int ecode2 = 0 ;
22761 PyObject * obj0 = 0 ;
22762 PyObject * obj1 = 0 ;
22763 char * kwnames[] = {
22764 (char *) "self",(char *) "pos", NULL
22765 };
22766
22767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22771 }
22772 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22773 ecode2 = SWIG_AsVal_int(obj1, &val2);
22774 if (!SWIG_IsOK(ecode2)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22776 }
22777 arg2 = static_cast< int >(val2);
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 (arg1)->SetPosition(arg2);
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 resultobj = SWIG_Py_Void();
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *obj;
22793 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22794 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22795 return SWIG_Py_Void();
22796 }
22797
22798 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22799 return SWIG_Python_InitShadowInstance(args);
22800 }
22801
22802 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22803 PyObject *resultobj = 0;
22804 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22805 wxMouseEvent *result = 0 ;
22806 int val1 ;
22807 int ecode1 = 0 ;
22808 PyObject * obj0 = 0 ;
22809 char * kwnames[] = {
22810 (char *) "mouseType", NULL
22811 };
22812
22813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22814 if (obj0) {
22815 ecode1 = SWIG_AsVal_int(obj0, &val1);
22816 if (!SWIG_IsOK(ecode1)) {
22817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22818 }
22819 arg1 = static_cast< wxEventType >(val1);
22820 }
22821 {
22822 PyThreadState* __tstate = wxPyBeginAllowThreads();
22823 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22824 wxPyEndAllowThreads(__tstate);
22825 if (PyErr_Occurred()) SWIG_fail;
22826 }
22827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22828 return resultobj;
22829 fail:
22830 return NULL;
22831 }
22832
22833
22834 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22835 PyObject *resultobj = 0;
22836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22837 bool result;
22838 void *argp1 = 0 ;
22839 int res1 = 0 ;
22840 PyObject *swig_obj[1] ;
22841
22842 if (!args) SWIG_fail;
22843 swig_obj[0] = args;
22844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22845 if (!SWIG_IsOK(res1)) {
22846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22847 }
22848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 {
22856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22857 }
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22865 PyObject *resultobj = 0;
22866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22867 int arg2 = (int) wxMOUSE_BTN_ANY ;
22868 bool result;
22869 void *argp1 = 0 ;
22870 int res1 = 0 ;
22871 int val2 ;
22872 int ecode2 = 0 ;
22873 PyObject * obj0 = 0 ;
22874 PyObject * obj1 = 0 ;
22875 char * kwnames[] = {
22876 (char *) "self",(char *) "but", NULL
22877 };
22878
22879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22881 if (!SWIG_IsOK(res1)) {
22882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22883 }
22884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22885 if (obj1) {
22886 ecode2 = SWIG_AsVal_int(obj1, &val2);
22887 if (!SWIG_IsOK(ecode2)) {
22888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22889 }
22890 arg2 = static_cast< int >(val2);
22891 }
22892 {
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 {
22899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22908 PyObject *resultobj = 0;
22909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22910 int arg2 = (int) wxMOUSE_BTN_ANY ;
22911 bool result;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 int val2 ;
22915 int ecode2 = 0 ;
22916 PyObject * obj0 = 0 ;
22917 PyObject * obj1 = 0 ;
22918 char * kwnames[] = {
22919 (char *) "self",(char *) "but", NULL
22920 };
22921
22922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22926 }
22927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22928 if (obj1) {
22929 ecode2 = SWIG_AsVal_int(obj1, &val2);
22930 if (!SWIG_IsOK(ecode2)) {
22931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22932 }
22933 arg2 = static_cast< int >(val2);
22934 }
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 {
22942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22943 }
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22951 PyObject *resultobj = 0;
22952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22953 int arg2 = (int) wxMOUSE_BTN_ANY ;
22954 bool result;
22955 void *argp1 = 0 ;
22956 int res1 = 0 ;
22957 int val2 ;
22958 int ecode2 = 0 ;
22959 PyObject * obj0 = 0 ;
22960 PyObject * obj1 = 0 ;
22961 char * kwnames[] = {
22962 (char *) "self",(char *) "but", NULL
22963 };
22964
22965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22971 if (obj1) {
22972 ecode2 = SWIG_AsVal_int(obj1, &val2);
22973 if (!SWIG_IsOK(ecode2)) {
22974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22975 }
22976 arg2 = static_cast< int >(val2);
22977 }
22978 {
22979 PyThreadState* __tstate = wxPyBeginAllowThreads();
22980 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22994 PyObject *resultobj = 0;
22995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22996 int arg2 ;
22997 bool result;
22998 void *argp1 = 0 ;
22999 int res1 = 0 ;
23000 int val2 ;
23001 int ecode2 = 0 ;
23002 PyObject * obj0 = 0 ;
23003 PyObject * obj1 = 0 ;
23004 char * kwnames[] = {
23005 (char *) "self",(char *) "button", NULL
23006 };
23007
23008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23010 if (!SWIG_IsOK(res1)) {
23011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23012 }
23013 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23014 ecode2 = SWIG_AsVal_int(obj1, &val2);
23015 if (!SWIG_IsOK(ecode2)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23017 }
23018 arg2 = static_cast< int >(val2);
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 {
23026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23027 }
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj = 0;
23036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23037 int arg2 ;
23038 bool result;
23039 void *argp1 = 0 ;
23040 int res1 = 0 ;
23041 int val2 ;
23042 int ecode2 = 0 ;
23043 PyObject * obj0 = 0 ;
23044 PyObject * obj1 = 0 ;
23045 char * kwnames[] = {
23046 (char *) "self",(char *) "but", NULL
23047 };
23048
23049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23053 }
23054 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23055 ecode2 = SWIG_AsVal_int(obj1, &val2);
23056 if (!SWIG_IsOK(ecode2)) {
23057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23058 }
23059 arg2 = static_cast< int >(val2);
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23068 }
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23076 PyObject *resultobj = 0;
23077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23078 int result;
23079 void *argp1 = 0 ;
23080 int res1 = 0 ;
23081 PyObject *swig_obj[1] ;
23082
23083 if (!args) SWIG_fail;
23084 swig_obj[0] = args;
23085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23086 if (!SWIG_IsOK(res1)) {
23087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23088 }
23089 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23090 {
23091 PyThreadState* __tstate = wxPyBeginAllowThreads();
23092 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23093 wxPyEndAllowThreads(__tstate);
23094 if (PyErr_Occurred()) SWIG_fail;
23095 }
23096 resultobj = SWIG_From_int(static_cast< int >(result));
23097 return resultobj;
23098 fail:
23099 return NULL;
23100 }
23101
23102
23103 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23104 PyObject *resultobj = 0;
23105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23106 bool result;
23107 void *argp1 = 0 ;
23108 int res1 = 0 ;
23109 PyObject *swig_obj[1] ;
23110
23111 if (!args) SWIG_fail;
23112 swig_obj[0] = args;
23113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23114 if (!SWIG_IsOK(res1)) {
23115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23116 }
23117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23121 wxPyEndAllowThreads(__tstate);
23122 if (PyErr_Occurred()) SWIG_fail;
23123 }
23124 {
23125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23126 }
23127 return resultobj;
23128 fail:
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23134 PyObject *resultobj = 0;
23135 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23136 bool result;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 PyObject *swig_obj[1] ;
23140
23141 if (!args) SWIG_fail;
23142 swig_obj[0] = args;
23143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23144 if (!SWIG_IsOK(res1)) {
23145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23146 }
23147 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23151 wxPyEndAllowThreads(__tstate);
23152 if (PyErr_Occurred()) SWIG_fail;
23153 }
23154 {
23155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23156 }
23157 return resultobj;
23158 fail:
23159 return NULL;
23160 }
23161
23162
23163 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23164 PyObject *resultobj = 0;
23165 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23166 bool result;
23167 void *argp1 = 0 ;
23168 int res1 = 0 ;
23169 PyObject *swig_obj[1] ;
23170
23171 if (!args) SWIG_fail;
23172 swig_obj[0] = args;
23173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23174 if (!SWIG_IsOK(res1)) {
23175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23176 }
23177 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23181 wxPyEndAllowThreads(__tstate);
23182 if (PyErr_Occurred()) SWIG_fail;
23183 }
23184 {
23185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23186 }
23187 return resultobj;
23188 fail:
23189 return NULL;
23190 }
23191
23192
23193 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23194 PyObject *resultobj = 0;
23195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23196 bool result;
23197 void *argp1 = 0 ;
23198 int res1 = 0 ;
23199 PyObject *swig_obj[1] ;
23200
23201 if (!args) SWIG_fail;
23202 swig_obj[0] = args;
23203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23204 if (!SWIG_IsOK(res1)) {
23205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23206 }
23207 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 {
23215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23216 }
23217 return resultobj;
23218 fail:
23219 return NULL;
23220 }
23221
23222
23223 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23224 PyObject *resultobj = 0;
23225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23226 bool result;
23227 void *argp1 = 0 ;
23228 int res1 = 0 ;
23229 PyObject *swig_obj[1] ;
23230
23231 if (!args) SWIG_fail;
23232 swig_obj[0] = args;
23233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23234 if (!SWIG_IsOK(res1)) {
23235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23236 }
23237 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23241 wxPyEndAllowThreads(__tstate);
23242 if (PyErr_Occurred()) SWIG_fail;
23243 }
23244 {
23245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23246 }
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23254 PyObject *resultobj = 0;
23255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23256 bool result;
23257 void *argp1 = 0 ;
23258 int res1 = 0 ;
23259 PyObject *swig_obj[1] ;
23260
23261 if (!args) SWIG_fail;
23262 swig_obj[0] = args;
23263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23264 if (!SWIG_IsOK(res1)) {
23265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23266 }
23267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23268 {
23269 PyThreadState* __tstate = wxPyBeginAllowThreads();
23270 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 {
23275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23276 }
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284 PyObject *resultobj = 0;
23285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23286 bool result;
23287 void *argp1 = 0 ;
23288 int res1 = 0 ;
23289 PyObject *swig_obj[1] ;
23290
23291 if (!args) SWIG_fail;
23292 swig_obj[0] = args;
23293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23294 if (!SWIG_IsOK(res1)) {
23295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23296 }
23297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23301 wxPyEndAllowThreads(__tstate);
23302 if (PyErr_Occurred()) SWIG_fail;
23303 }
23304 {
23305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23306 }
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23314 PyObject *resultobj = 0;
23315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23316 bool result;
23317 void *argp1 = 0 ;
23318 int res1 = 0 ;
23319 PyObject *swig_obj[1] ;
23320
23321 if (!args) SWIG_fail;
23322 swig_obj[0] = args;
23323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23324 if (!SWIG_IsOK(res1)) {
23325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23326 }
23327 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 {
23335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23336 }
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23344 PyObject *resultobj = 0;
23345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23346 bool result;
23347 void *argp1 = 0 ;
23348 int res1 = 0 ;
23349 PyObject *swig_obj[1] ;
23350
23351 if (!args) SWIG_fail;
23352 swig_obj[0] = args;
23353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23354 if (!SWIG_IsOK(res1)) {
23355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23356 }
23357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23358 {
23359 PyThreadState* __tstate = wxPyBeginAllowThreads();
23360 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 {
23365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23366 }
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 PyObject *resultobj = 0;
23375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23376 bool result;
23377 void *argp1 = 0 ;
23378 int res1 = 0 ;
23379 PyObject *swig_obj[1] ;
23380
23381 if (!args) SWIG_fail;
23382 swig_obj[0] = args;
23383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23384 if (!SWIG_IsOK(res1)) {
23385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23386 }
23387 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 {
23395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23396 }
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23404 PyObject *resultobj = 0;
23405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23406 bool result;
23407 void *argp1 = 0 ;
23408 int res1 = 0 ;
23409 PyObject *swig_obj[1] ;
23410
23411 if (!args) SWIG_fail;
23412 swig_obj[0] = args;
23413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23414 if (!SWIG_IsOK(res1)) {
23415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23416 }
23417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23421 wxPyEndAllowThreads(__tstate);
23422 if (PyErr_Occurred()) SWIG_fail;
23423 }
23424 {
23425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23434 PyObject *resultobj = 0;
23435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23436 bool result;
23437 void *argp1 = 0 ;
23438 int res1 = 0 ;
23439 PyObject *swig_obj[1] ;
23440
23441 if (!args) SWIG_fail;
23442 swig_obj[0] = args;
23443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23444 if (!SWIG_IsOK(res1)) {
23445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23446 }
23447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23448 {
23449 PyThreadState* __tstate = wxPyBeginAllowThreads();
23450 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 {
23455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23456 }
23457 return resultobj;
23458 fail:
23459 return NULL;
23460 }
23461
23462
23463 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23464 PyObject *resultobj = 0;
23465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23466 bool result;
23467 void *argp1 = 0 ;
23468 int res1 = 0 ;
23469 PyObject *swig_obj[1] ;
23470
23471 if (!args) SWIG_fail;
23472 swig_obj[0] = args;
23473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23474 if (!SWIG_IsOK(res1)) {
23475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23476 }
23477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23481 wxPyEndAllowThreads(__tstate);
23482 if (PyErr_Occurred()) SWIG_fail;
23483 }
23484 {
23485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23486 }
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23494 PyObject *resultobj = 0;
23495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23496 bool result;
23497 void *argp1 = 0 ;
23498 int res1 = 0 ;
23499 PyObject *swig_obj[1] ;
23500
23501 if (!args) SWIG_fail;
23502 swig_obj[0] = args;
23503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23504 if (!SWIG_IsOK(res1)) {
23505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23506 }
23507 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23511 wxPyEndAllowThreads(__tstate);
23512 if (PyErr_Occurred()) SWIG_fail;
23513 }
23514 {
23515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23516 }
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 PyObject *resultobj = 0;
23525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23526 bool result;
23527 void *argp1 = 0 ;
23528 int res1 = 0 ;
23529 PyObject *swig_obj[1] ;
23530
23531 if (!args) SWIG_fail;
23532 swig_obj[0] = args;
23533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23534 if (!SWIG_IsOK(res1)) {
23535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23536 }
23537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = (bool)(arg1)->LeftIsDown();
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 {
23545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23546 }
23547 return resultobj;
23548 fail:
23549 return NULL;
23550 }
23551
23552
23553 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23554 PyObject *resultobj = 0;
23555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23556 bool result;
23557 void *argp1 = 0 ;
23558 int res1 = 0 ;
23559 PyObject *swig_obj[1] ;
23560
23561 if (!args) SWIG_fail;
23562 swig_obj[0] = args;
23563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23564 if (!SWIG_IsOK(res1)) {
23565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23566 }
23567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 result = (bool)(arg1)->MiddleIsDown();
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23576 }
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23584 PyObject *resultobj = 0;
23585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23586 bool result;
23587 void *argp1 = 0 ;
23588 int res1 = 0 ;
23589 PyObject *swig_obj[1] ;
23590
23591 if (!args) SWIG_fail;
23592 swig_obj[0] = args;
23593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23594 if (!SWIG_IsOK(res1)) {
23595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23596 }
23597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 result = (bool)(arg1)->RightIsDown();
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 {
23605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23606 }
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23616 bool result;
23617 void *argp1 = 0 ;
23618 int res1 = 0 ;
23619 PyObject *swig_obj[1] ;
23620
23621 if (!args) SWIG_fail;
23622 swig_obj[0] = args;
23623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23624 if (!SWIG_IsOK(res1)) {
23625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23626 }
23627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 {
23635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23636 }
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23644 PyObject *resultobj = 0;
23645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23646 bool result;
23647 void *argp1 = 0 ;
23648 int res1 = 0 ;
23649 PyObject *swig_obj[1] ;
23650
23651 if (!args) SWIG_fail;
23652 swig_obj[0] = args;
23653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23654 if (!SWIG_IsOK(res1)) {
23655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23656 }
23657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23658 {
23659 PyThreadState* __tstate = wxPyBeginAllowThreads();
23660 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23661 wxPyEndAllowThreads(__tstate);
23662 if (PyErr_Occurred()) SWIG_fail;
23663 }
23664 {
23665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23666 }
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23674 PyObject *resultobj = 0;
23675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23676 bool result;
23677 void *argp1 = 0 ;
23678 int res1 = 0 ;
23679 PyObject *swig_obj[1] ;
23680
23681 if (!args) SWIG_fail;
23682 swig_obj[0] = args;
23683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23684 if (!SWIG_IsOK(res1)) {
23685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23686 }
23687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23704 PyObject *resultobj = 0;
23705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23706 bool result;
23707 void *argp1 = 0 ;
23708 int res1 = 0 ;
23709 PyObject *swig_obj[1] ;
23710
23711 if (!args) SWIG_fail;
23712 swig_obj[0] = args;
23713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23716 }
23717 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 PyObject *resultobj = 0;
23735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23736 wxPoint result;
23737 void *argp1 = 0 ;
23738 int res1 = 0 ;
23739 PyObject *swig_obj[1] ;
23740
23741 if (!args) SWIG_fail;
23742 swig_obj[0] = args;
23743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23744 if (!SWIG_IsOK(res1)) {
23745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23746 }
23747 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = (arg1)->GetPosition();
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23762 PyObject *resultobj = 0;
23763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23764 long *arg2 = (long *) 0 ;
23765 long *arg3 = (long *) 0 ;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 long temp2 ;
23769 int res2 = SWIG_TMPOBJ ;
23770 long temp3 ;
23771 int res3 = SWIG_TMPOBJ ;
23772 PyObject *swig_obj[1] ;
23773
23774 arg2 = &temp2;
23775 arg3 = &temp3;
23776 if (!args) SWIG_fail;
23777 swig_obj[0] = args;
23778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23779 if (!SWIG_IsOK(res1)) {
23780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23781 }
23782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 (arg1)->GetPosition(arg2,arg3);
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_Py_Void();
23790 if (SWIG_IsTmpObj(res2)) {
23791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23792 } else {
23793 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23795 }
23796 if (SWIG_IsTmpObj(res3)) {
23797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23798 } else {
23799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23809 PyObject *resultobj = 0;
23810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23811 wxDC *arg2 = 0 ;
23812 wxPoint result;
23813 void *argp1 = 0 ;
23814 int res1 = 0 ;
23815 void *argp2 = 0 ;
23816 int res2 = 0 ;
23817 PyObject * obj0 = 0 ;
23818 PyObject * obj1 = 0 ;
23819 char * kwnames[] = {
23820 (char *) "self",(char *) "dc", NULL
23821 };
23822
23823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23825 if (!SWIG_IsOK(res1)) {
23826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23827 }
23828 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23829 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23830 if (!SWIG_IsOK(res2)) {
23831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23832 }
23833 if (!argp2) {
23834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23835 }
23836 arg2 = reinterpret_cast< wxDC * >(argp2);
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851 PyObject *resultobj = 0;
23852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23853 int result;
23854 void *argp1 = 0 ;
23855 int res1 = 0 ;
23856 PyObject *swig_obj[1] ;
23857
23858 if (!args) SWIG_fail;
23859 swig_obj[0] = args;
23860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23861 if (!SWIG_IsOK(res1)) {
23862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23863 }
23864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = (int)((wxMouseEvent const *)arg1)->GetX();
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 resultobj = SWIG_From_int(static_cast< int >(result));
23872 return resultobj;
23873 fail:
23874 return NULL;
23875 }
23876
23877
23878 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23879 PyObject *resultobj = 0;
23880 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23881 int result;
23882 void *argp1 = 0 ;
23883 int res1 = 0 ;
23884 PyObject *swig_obj[1] ;
23885
23886 if (!args) SWIG_fail;
23887 swig_obj[0] = args;
23888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23889 if (!SWIG_IsOK(res1)) {
23890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23891 }
23892 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 result = (int)((wxMouseEvent const *)arg1)->GetY();
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 resultobj = SWIG_From_int(static_cast< int >(result));
23900 return resultobj;
23901 fail:
23902 return NULL;
23903 }
23904
23905
23906 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23907 PyObject *resultobj = 0;
23908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23909 int result;
23910 void *argp1 = 0 ;
23911 int res1 = 0 ;
23912 PyObject *swig_obj[1] ;
23913
23914 if (!args) SWIG_fail;
23915 swig_obj[0] = args;
23916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23917 if (!SWIG_IsOK(res1)) {
23918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23919 }
23920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_From_int(static_cast< int >(result));
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 PyObject *resultobj = 0;
23936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23937 int result;
23938 void *argp1 = 0 ;
23939 int res1 = 0 ;
23940 PyObject *swig_obj[1] ;
23941
23942 if (!args) SWIG_fail;
23943 swig_obj[0] = args;
23944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23945 if (!SWIG_IsOK(res1)) {
23946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23947 }
23948 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 resultobj = SWIG_From_int(static_cast< int >(result));
23956 return resultobj;
23957 fail:
23958 return NULL;
23959 }
23960
23961
23962 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23963 PyObject *resultobj = 0;
23964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23965 int result;
23966 void *argp1 = 0 ;
23967 int res1 = 0 ;
23968 PyObject *swig_obj[1] ;
23969
23970 if (!args) SWIG_fail;
23971 swig_obj[0] = args;
23972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23975 }
23976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_From_int(static_cast< int >(result));
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23991 PyObject *resultobj = 0;
23992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23993 bool result;
23994 void *argp1 = 0 ;
23995 int res1 = 0 ;
23996 PyObject *swig_obj[1] ;
23997
23998 if (!args) SWIG_fail;
23999 swig_obj[0] = args;
24000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24001 if (!SWIG_IsOK(res1)) {
24002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24003 }
24004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 {
24012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24013 }
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021 PyObject *resultobj = 0;
24022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24023 int arg2 ;
24024 void *argp1 = 0 ;
24025 int res1 = 0 ;
24026 int val2 ;
24027 int ecode2 = 0 ;
24028 PyObject *swig_obj[2] ;
24029
24030 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24036 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24037 if (!SWIG_IsOK(ecode2)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24039 }
24040 arg2 = static_cast< int >(val2);
24041 if (arg1) (arg1)->m_x = arg2;
24042
24043 resultobj = SWIG_Py_Void();
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24051 PyObject *resultobj = 0;
24052 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24053 int result;
24054 void *argp1 = 0 ;
24055 int res1 = 0 ;
24056 PyObject *swig_obj[1] ;
24057
24058 if (!args) SWIG_fail;
24059 swig_obj[0] = args;
24060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24061 if (!SWIG_IsOK(res1)) {
24062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24063 }
24064 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24065 result = (int) ((arg1)->m_x);
24066 resultobj = SWIG_From_int(static_cast< int >(result));
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24074 PyObject *resultobj = 0;
24075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24076 int arg2 ;
24077 void *argp1 = 0 ;
24078 int res1 = 0 ;
24079 int val2 ;
24080 int ecode2 = 0 ;
24081 PyObject *swig_obj[2] ;
24082
24083 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24087 }
24088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24089 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24090 if (!SWIG_IsOK(ecode2)) {
24091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24092 }
24093 arg2 = static_cast< int >(val2);
24094 if (arg1) (arg1)->m_y = arg2;
24095
24096 resultobj = SWIG_Py_Void();
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24104 PyObject *resultobj = 0;
24105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24106 int result;
24107 void *argp1 = 0 ;
24108 int res1 = 0 ;
24109 PyObject *swig_obj[1] ;
24110
24111 if (!args) SWIG_fail;
24112 swig_obj[0] = args;
24113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24114 if (!SWIG_IsOK(res1)) {
24115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24116 }
24117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24118 result = (int) ((arg1)->m_y);
24119 resultobj = SWIG_From_int(static_cast< int >(result));
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24127 PyObject *resultobj = 0;
24128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24129 bool arg2 ;
24130 void *argp1 = 0 ;
24131 int res1 = 0 ;
24132 bool val2 ;
24133 int ecode2 = 0 ;
24134 PyObject *swig_obj[2] ;
24135
24136 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24138 if (!SWIG_IsOK(res1)) {
24139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24140 }
24141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24142 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24143 if (!SWIG_IsOK(ecode2)) {
24144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24145 }
24146 arg2 = static_cast< bool >(val2);
24147 if (arg1) (arg1)->m_leftDown = arg2;
24148
24149 resultobj = SWIG_Py_Void();
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24157 PyObject *resultobj = 0;
24158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24159 bool result;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 PyObject *swig_obj[1] ;
24163
24164 if (!args) SWIG_fail;
24165 swig_obj[0] = args;
24166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24167 if (!SWIG_IsOK(res1)) {
24168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24169 }
24170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24171 result = (bool) ((arg1)->m_leftDown);
24172 {
24173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24174 }
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24182 PyObject *resultobj = 0;
24183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24184 bool arg2 ;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 bool val2 ;
24188 int ecode2 = 0 ;
24189 PyObject *swig_obj[2] ;
24190
24191 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24193 if (!SWIG_IsOK(res1)) {
24194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24195 }
24196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24197 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24198 if (!SWIG_IsOK(ecode2)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24200 }
24201 arg2 = static_cast< bool >(val2);
24202 if (arg1) (arg1)->m_middleDown = arg2;
24203
24204 resultobj = SWIG_Py_Void();
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24212 PyObject *resultobj = 0;
24213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24214 bool result;
24215 void *argp1 = 0 ;
24216 int res1 = 0 ;
24217 PyObject *swig_obj[1] ;
24218
24219 if (!args) SWIG_fail;
24220 swig_obj[0] = args;
24221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24222 if (!SWIG_IsOK(res1)) {
24223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24224 }
24225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24226 result = (bool) ((arg1)->m_middleDown);
24227 {
24228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24229 }
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24237 PyObject *resultobj = 0;
24238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24239 bool arg2 ;
24240 void *argp1 = 0 ;
24241 int res1 = 0 ;
24242 bool val2 ;
24243 int ecode2 = 0 ;
24244 PyObject *swig_obj[2] ;
24245
24246 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24248 if (!SWIG_IsOK(res1)) {
24249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24250 }
24251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24252 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24253 if (!SWIG_IsOK(ecode2)) {
24254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24255 }
24256 arg2 = static_cast< bool >(val2);
24257 if (arg1) (arg1)->m_rightDown = arg2;
24258
24259 resultobj = SWIG_Py_Void();
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *resultobj = 0;
24268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24269 bool result;
24270 void *argp1 = 0 ;
24271 int res1 = 0 ;
24272 PyObject *swig_obj[1] ;
24273
24274 if (!args) SWIG_fail;
24275 swig_obj[0] = args;
24276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24279 }
24280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24281 result = (bool) ((arg1)->m_rightDown);
24282 {
24283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24284 }
24285 return resultobj;
24286 fail:
24287 return NULL;
24288 }
24289
24290
24291 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24292 PyObject *resultobj = 0;
24293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24294 bool arg2 ;
24295 void *argp1 = 0 ;
24296 int res1 = 0 ;
24297 bool val2 ;
24298 int ecode2 = 0 ;
24299 PyObject *swig_obj[2] ;
24300
24301 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24303 if (!SWIG_IsOK(res1)) {
24304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24305 }
24306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24307 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24308 if (!SWIG_IsOK(ecode2)) {
24309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24310 }
24311 arg2 = static_cast< bool >(val2);
24312 if (arg1) (arg1)->m_controlDown = arg2;
24313
24314 resultobj = SWIG_Py_Void();
24315 return resultobj;
24316 fail:
24317 return NULL;
24318 }
24319
24320
24321 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24322 PyObject *resultobj = 0;
24323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24324 bool result;
24325 void *argp1 = 0 ;
24326 int res1 = 0 ;
24327 PyObject *swig_obj[1] ;
24328
24329 if (!args) SWIG_fail;
24330 swig_obj[0] = args;
24331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24332 if (!SWIG_IsOK(res1)) {
24333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24334 }
24335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24336 result = (bool) ((arg1)->m_controlDown);
24337 {
24338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24339 }
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24347 PyObject *resultobj = 0;
24348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24349 bool arg2 ;
24350 void *argp1 = 0 ;
24351 int res1 = 0 ;
24352 bool val2 ;
24353 int ecode2 = 0 ;
24354 PyObject *swig_obj[2] ;
24355
24356 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24358 if (!SWIG_IsOK(res1)) {
24359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24360 }
24361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24362 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24363 if (!SWIG_IsOK(ecode2)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24365 }
24366 arg2 = static_cast< bool >(val2);
24367 if (arg1) (arg1)->m_shiftDown = arg2;
24368
24369 resultobj = SWIG_Py_Void();
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 PyObject *resultobj = 0;
24378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24379 bool result;
24380 void *argp1 = 0 ;
24381 int res1 = 0 ;
24382 PyObject *swig_obj[1] ;
24383
24384 if (!args) SWIG_fail;
24385 swig_obj[0] = args;
24386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24387 if (!SWIG_IsOK(res1)) {
24388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24389 }
24390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24391 result = (bool) ((arg1)->m_shiftDown);
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24402 PyObject *resultobj = 0;
24403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24404 bool arg2 ;
24405 void *argp1 = 0 ;
24406 int res1 = 0 ;
24407 bool val2 ;
24408 int ecode2 = 0 ;
24409 PyObject *swig_obj[2] ;
24410
24411 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24415 }
24416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24417 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24418 if (!SWIG_IsOK(ecode2)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24420 }
24421 arg2 = static_cast< bool >(val2);
24422 if (arg1) (arg1)->m_altDown = arg2;
24423
24424 resultobj = SWIG_Py_Void();
24425 return resultobj;
24426 fail:
24427 return NULL;
24428 }
24429
24430
24431 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24432 PyObject *resultobj = 0;
24433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24434 bool result;
24435 void *argp1 = 0 ;
24436 int res1 = 0 ;
24437 PyObject *swig_obj[1] ;
24438
24439 if (!args) SWIG_fail;
24440 swig_obj[0] = args;
24441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24442 if (!SWIG_IsOK(res1)) {
24443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24444 }
24445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24446 result = (bool) ((arg1)->m_altDown);
24447 {
24448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24449 }
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24457 PyObject *resultobj = 0;
24458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24459 bool arg2 ;
24460 void *argp1 = 0 ;
24461 int res1 = 0 ;
24462 bool val2 ;
24463 int ecode2 = 0 ;
24464 PyObject *swig_obj[2] ;
24465
24466 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24468 if (!SWIG_IsOK(res1)) {
24469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24470 }
24471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24472 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24473 if (!SWIG_IsOK(ecode2)) {
24474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24475 }
24476 arg2 = static_cast< bool >(val2);
24477 if (arg1) (arg1)->m_metaDown = arg2;
24478
24479 resultobj = SWIG_Py_Void();
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24487 PyObject *resultobj = 0;
24488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24489 bool result;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 PyObject *swig_obj[1] ;
24493
24494 if (!args) SWIG_fail;
24495 swig_obj[0] = args;
24496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24497 if (!SWIG_IsOK(res1)) {
24498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24499 }
24500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24501 result = (bool) ((arg1)->m_metaDown);
24502 {
24503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24504 }
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24512 PyObject *resultobj = 0;
24513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24514 int arg2 ;
24515 void *argp1 = 0 ;
24516 int res1 = 0 ;
24517 int val2 ;
24518 int ecode2 = 0 ;
24519 PyObject *swig_obj[2] ;
24520
24521 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24523 if (!SWIG_IsOK(res1)) {
24524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24525 }
24526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24527 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24528 if (!SWIG_IsOK(ecode2)) {
24529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24530 }
24531 arg2 = static_cast< int >(val2);
24532 if (arg1) (arg1)->m_wheelRotation = arg2;
24533
24534 resultobj = SWIG_Py_Void();
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 PyObject *resultobj = 0;
24543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24544 int result;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 PyObject *swig_obj[1] ;
24548
24549 if (!args) SWIG_fail;
24550 swig_obj[0] = args;
24551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24552 if (!SWIG_IsOK(res1)) {
24553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24554 }
24555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24556 result = (int) ((arg1)->m_wheelRotation);
24557 resultobj = SWIG_From_int(static_cast< int >(result));
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24565 PyObject *resultobj = 0;
24566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24567 int arg2 ;
24568 void *argp1 = 0 ;
24569 int res1 = 0 ;
24570 int val2 ;
24571 int ecode2 = 0 ;
24572 PyObject *swig_obj[2] ;
24573
24574 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24578 }
24579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24581 if (!SWIG_IsOK(ecode2)) {
24582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24583 }
24584 arg2 = static_cast< int >(val2);
24585 if (arg1) (arg1)->m_wheelDelta = arg2;
24586
24587 resultobj = SWIG_Py_Void();
24588 return resultobj;
24589 fail:
24590 return NULL;
24591 }
24592
24593
24594 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24595 PyObject *resultobj = 0;
24596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24597 int result;
24598 void *argp1 = 0 ;
24599 int res1 = 0 ;
24600 PyObject *swig_obj[1] ;
24601
24602 if (!args) SWIG_fail;
24603 swig_obj[0] = args;
24604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24605 if (!SWIG_IsOK(res1)) {
24606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24607 }
24608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24609 result = (int) ((arg1)->m_wheelDelta);
24610 resultobj = SWIG_From_int(static_cast< int >(result));
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24618 PyObject *resultobj = 0;
24619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24620 int arg2 ;
24621 void *argp1 = 0 ;
24622 int res1 = 0 ;
24623 int val2 ;
24624 int ecode2 = 0 ;
24625 PyObject *swig_obj[2] ;
24626
24627 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24629 if (!SWIG_IsOK(res1)) {
24630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24631 }
24632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24634 if (!SWIG_IsOK(ecode2)) {
24635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24636 }
24637 arg2 = static_cast< int >(val2);
24638 if (arg1) (arg1)->m_linesPerAction = arg2;
24639
24640 resultobj = SWIG_Py_Void();
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24648 PyObject *resultobj = 0;
24649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24650 int 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_wxMouseEvent, 0 | 0 );
24658 if (!SWIG_IsOK(res1)) {
24659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24660 }
24661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24662 result = (int) ((arg1)->m_linesPerAction);
24663 resultobj = SWIG_From_int(static_cast< int >(result));
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671 PyObject *obj;
24672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24673 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24674 return SWIG_Py_Void();
24675 }
24676
24677 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 return SWIG_Python_InitShadowInstance(args);
24679 }
24680
24681 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj = 0;
24683 int arg1 = (int) 0 ;
24684 int arg2 = (int) 0 ;
24685 wxSetCursorEvent *result = 0 ;
24686 int val1 ;
24687 int ecode1 = 0 ;
24688 int val2 ;
24689 int ecode2 = 0 ;
24690 PyObject * obj0 = 0 ;
24691 PyObject * obj1 = 0 ;
24692 char * kwnames[] = {
24693 (char *) "x",(char *) "y", NULL
24694 };
24695
24696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24697 if (obj0) {
24698 ecode1 = SWIG_AsVal_int(obj0, &val1);
24699 if (!SWIG_IsOK(ecode1)) {
24700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24701 }
24702 arg1 = static_cast< int >(val1);
24703 }
24704 if (obj1) {
24705 ecode2 = SWIG_AsVal_int(obj1, &val2);
24706 if (!SWIG_IsOK(ecode2)) {
24707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24708 }
24709 arg2 = static_cast< int >(val2);
24710 }
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24727 int result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 resultobj = SWIG_From_int(static_cast< int >(result));
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24755 int result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 resultobj = SWIG_From_int(static_cast< int >(result));
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24781 PyObject *resultobj = 0;
24782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24783 wxCursor *arg2 = 0 ;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 void *argp2 = 0 ;
24787 int res2 = 0 ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "self",(char *) "cursor", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24798 }
24799 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24801 if (!SWIG_IsOK(res2)) {
24802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24803 }
24804 if (!argp2) {
24805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24806 }
24807 arg2 = reinterpret_cast< wxCursor * >(argp2);
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 (arg1)->SetCursor((wxCursor const &)*arg2);
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 resultobj = SWIG_Py_Void();
24815 return resultobj;
24816 fail:
24817 return NULL;
24818 }
24819
24820
24821 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24822 PyObject *resultobj = 0;
24823 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24824 wxCursor *result = 0 ;
24825 void *argp1 = 0 ;
24826 int res1 = 0 ;
24827 PyObject *swig_obj[1] ;
24828
24829 if (!args) SWIG_fail;
24830 swig_obj[0] = args;
24831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24832 if (!SWIG_IsOK(res1)) {
24833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24834 }
24835 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 {
24839 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24840 result = (wxCursor *) &_result_ref;
24841 }
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 {
24846 wxCursor* resultptr = new wxCursor(*result);
24847 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24848 }
24849 return resultobj;
24850 fail:
24851 return NULL;
24852 }
24853
24854
24855 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24856 PyObject *resultobj = 0;
24857 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24858 bool result;
24859 void *argp1 = 0 ;
24860 int res1 = 0 ;
24861 PyObject *swig_obj[1] ;
24862
24863 if (!args) SWIG_fail;
24864 swig_obj[0] = args;
24865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24866 if (!SWIG_IsOK(res1)) {
24867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24868 }
24869 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24873 wxPyEndAllowThreads(__tstate);
24874 if (PyErr_Occurred()) SWIG_fail;
24875 }
24876 {
24877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24878 }
24879 return resultobj;
24880 fail:
24881 return NULL;
24882 }
24883
24884
24885 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 PyObject *obj;
24887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24888 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24889 return SWIG_Py_Void();
24890 }
24891
24892 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 return SWIG_Python_InitShadowInstance(args);
24894 }
24895
24896 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj = 0;
24898 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24899 wxKeyEvent *result = 0 ;
24900 int val1 ;
24901 int ecode1 = 0 ;
24902 PyObject * obj0 = 0 ;
24903 char * kwnames[] = {
24904 (char *) "eventType", NULL
24905 };
24906
24907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24908 if (obj0) {
24909 ecode1 = SWIG_AsVal_int(obj0, &val1);
24910 if (!SWIG_IsOK(ecode1)) {
24911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24912 }
24913 arg1 = static_cast< wxEventType >(val1);
24914 }
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24929 PyObject *resultobj = 0;
24930 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24931 int result;
24932 void *argp1 = 0 ;
24933 int res1 = 0 ;
24934 PyObject *swig_obj[1] ;
24935
24936 if (!args) SWIG_fail;
24937 swig_obj[0] = args;
24938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24939 if (!SWIG_IsOK(res1)) {
24940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24941 }
24942 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24946 wxPyEndAllowThreads(__tstate);
24947 if (PyErr_Occurred()) SWIG_fail;
24948 }
24949 resultobj = SWIG_From_int(static_cast< int >(result));
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24957 PyObject *resultobj = 0;
24958 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24959 bool result;
24960 void *argp1 = 0 ;
24961 int res1 = 0 ;
24962 PyObject *swig_obj[1] ;
24963
24964 if (!args) SWIG_fail;
24965 swig_obj[0] = args;
24966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24969 }
24970 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24974 wxPyEndAllowThreads(__tstate);
24975 if (PyErr_Occurred()) SWIG_fail;
24976 }
24977 {
24978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24979 }
24980 return resultobj;
24981 fail:
24982 return NULL;
24983 }
24984
24985
24986 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24987 PyObject *resultobj = 0;
24988 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24989 bool result;
24990 void *argp1 = 0 ;
24991 int res1 = 0 ;
24992 PyObject *swig_obj[1] ;
24993
24994 if (!args) SWIG_fail;
24995 swig_obj[0] = args;
24996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24997 if (!SWIG_IsOK(res1)) {
24998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24999 }
25000 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25001 {
25002 PyThreadState* __tstate = wxPyBeginAllowThreads();
25003 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25009 }
25010 return resultobj;
25011 fail:
25012 return NULL;
25013 }
25014
25015
25016 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25017 PyObject *resultobj = 0;
25018 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25019 bool result;
25020 void *argp1 = 0 ;
25021 int res1 = 0 ;
25022 PyObject *swig_obj[1] ;
25023
25024 if (!args) SWIG_fail;
25025 swig_obj[0] = args;
25026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25029 }
25030 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 {
25038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25039 }
25040 return resultobj;
25041 fail:
25042 return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25047 PyObject *resultobj = 0;
25048 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25049 bool result;
25050 void *argp1 = 0 ;
25051 int res1 = 0 ;
25052 PyObject *swig_obj[1] ;
25053
25054 if (!args) SWIG_fail;
25055 swig_obj[0] = args;
25056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25057 if (!SWIG_IsOK(res1)) {
25058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25059 }
25060 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 {
25068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25069 }
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25077 PyObject *resultobj = 0;
25078 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25079 bool result;
25080 void *argp1 = 0 ;
25081 int res1 = 0 ;
25082 PyObject *swig_obj[1] ;
25083
25084 if (!args) SWIG_fail;
25085 swig_obj[0] = args;
25086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25087 if (!SWIG_IsOK(res1)) {
25088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25089 }
25090 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25091 {
25092 PyThreadState* __tstate = wxPyBeginAllowThreads();
25093 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 {
25098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25099 }
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25107 PyObject *resultobj = 0;
25108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25109 bool result;
25110 void *argp1 = 0 ;
25111 int res1 = 0 ;
25112 PyObject *swig_obj[1] ;
25113
25114 if (!args) SWIG_fail;
25115 swig_obj[0] = args;
25116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25117 if (!SWIG_IsOK(res1)) {
25118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25119 }
25120 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25121 {
25122 PyThreadState* __tstate = wxPyBeginAllowThreads();
25123 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25124 wxPyEndAllowThreads(__tstate);
25125 if (PyErr_Occurred()) SWIG_fail;
25126 }
25127 {
25128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25129 }
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25137 PyObject *resultobj = 0;
25138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25139 int result;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 PyObject *swig_obj[1] ;
25143
25144 if (!args) SWIG_fail;
25145 swig_obj[0] = args;
25146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25149 }
25150 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_From_int(static_cast< int >(result));
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25167 int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25177 }
25178 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_From_int(static_cast< int >(result));
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25193 PyObject *resultobj = 0;
25194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25195 int arg2 ;
25196 void *argp1 = 0 ;
25197 int res1 = 0 ;
25198 int val2 ;
25199 int ecode2 = 0 ;
25200 PyObject * obj0 = 0 ;
25201 PyObject * obj1 = 0 ;
25202 char * kwnames[] = {
25203 (char *) "self",(char *) "uniChar", NULL
25204 };
25205
25206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25210 }
25211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25212 ecode2 = SWIG_AsVal_int(obj1, &val2);
25213 if (!SWIG_IsOK(ecode2)) {
25214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25215 }
25216 arg2 = static_cast< int >(val2);
25217 {
25218 PyThreadState* __tstate = wxPyBeginAllowThreads();
25219 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 resultobj = SWIG_Py_Void();
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25231 PyObject *resultobj = 0;
25232 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25233 unsigned int result;
25234 void *argp1 = 0 ;
25235 int res1 = 0 ;
25236 PyObject *swig_obj[1] ;
25237
25238 if (!args) SWIG_fail;
25239 swig_obj[0] = args;
25240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25243 }
25244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25252 return resultobj;
25253 fail:
25254 return NULL;
25255 }
25256
25257
25258 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25259 PyObject *resultobj = 0;
25260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25261 unsigned int result;
25262 void *argp1 = 0 ;
25263 int res1 = 0 ;
25264 PyObject *swig_obj[1] ;
25265
25266 if (!args) SWIG_fail;
25267 swig_obj[0] = args;
25268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25269 if (!SWIG_IsOK(res1)) {
25270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25271 }
25272 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25287 PyObject *resultobj = 0;
25288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25289 wxPoint result;
25290 void *argp1 = 0 ;
25291 int res1 = 0 ;
25292 PyObject *swig_obj[1] ;
25293
25294 if (!args) SWIG_fail;
25295 swig_obj[0] = args;
25296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25297 if (!SWIG_IsOK(res1)) {
25298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25299 }
25300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 result = (arg1)->GetPosition();
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25315 PyObject *resultobj = 0;
25316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25317 long *arg2 = (long *) 0 ;
25318 long *arg3 = (long *) 0 ;
25319 void *argp1 = 0 ;
25320 int res1 = 0 ;
25321 long temp2 ;
25322 int res2 = SWIG_TMPOBJ ;
25323 long temp3 ;
25324 int res3 = SWIG_TMPOBJ ;
25325 PyObject *swig_obj[1] ;
25326
25327 arg2 = &temp2;
25328 arg3 = &temp3;
25329 if (!args) SWIG_fail;
25330 swig_obj[0] = args;
25331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25332 if (!SWIG_IsOK(res1)) {
25333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25334 }
25335 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 (arg1)->GetPosition(arg2,arg3);
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 resultobj = SWIG_Py_Void();
25343 if (SWIG_IsTmpObj(res2)) {
25344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25345 } else {
25346 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25348 }
25349 if (SWIG_IsTmpObj(res3)) {
25350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25351 } else {
25352 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25354 }
25355 return resultobj;
25356 fail:
25357 return NULL;
25358 }
25359
25360
25361 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 PyObject *resultobj = 0;
25363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25364 int result;
25365 void *argp1 = 0 ;
25366 int res1 = 0 ;
25367 PyObject *swig_obj[1] ;
25368
25369 if (!args) SWIG_fail;
25370 swig_obj[0] = args;
25371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25372 if (!SWIG_IsOK(res1)) {
25373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25374 }
25375 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 result = (int)((wxKeyEvent const *)arg1)->GetX();
25379 wxPyEndAllowThreads(__tstate);
25380 if (PyErr_Occurred()) SWIG_fail;
25381 }
25382 resultobj = SWIG_From_int(static_cast< int >(result));
25383 return resultobj;
25384 fail:
25385 return NULL;
25386 }
25387
25388
25389 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25390 PyObject *resultobj = 0;
25391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25392 int result;
25393 void *argp1 = 0 ;
25394 int res1 = 0 ;
25395 PyObject *swig_obj[1] ;
25396
25397 if (!args) SWIG_fail;
25398 swig_obj[0] = args;
25399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25402 }
25403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 result = (int)((wxKeyEvent const *)arg1)->GetY();
25407 wxPyEndAllowThreads(__tstate);
25408 if (PyErr_Occurred()) SWIG_fail;
25409 }
25410 resultobj = SWIG_From_int(static_cast< int >(result));
25411 return resultobj;
25412 fail:
25413 return NULL;
25414 }
25415
25416
25417 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25418 PyObject *resultobj = 0;
25419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25420 int arg2 ;
25421 void *argp1 = 0 ;
25422 int res1 = 0 ;
25423 int val2 ;
25424 int ecode2 = 0 ;
25425 PyObject *swig_obj[2] ;
25426
25427 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25431 }
25432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25433 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25434 if (!SWIG_IsOK(ecode2)) {
25435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25436 }
25437 arg2 = static_cast< int >(val2);
25438 if (arg1) (arg1)->m_x = arg2;
25439
25440 resultobj = SWIG_Py_Void();
25441 return resultobj;
25442 fail:
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25448 PyObject *resultobj = 0;
25449 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25450 int result;
25451 void *argp1 = 0 ;
25452 int res1 = 0 ;
25453 PyObject *swig_obj[1] ;
25454
25455 if (!args) SWIG_fail;
25456 swig_obj[0] = args;
25457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25458 if (!SWIG_IsOK(res1)) {
25459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25460 }
25461 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25462 result = (int) ((arg1)->m_x);
25463 resultobj = SWIG_From_int(static_cast< int >(result));
25464 return resultobj;
25465 fail:
25466 return NULL;
25467 }
25468
25469
25470 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25471 PyObject *resultobj = 0;
25472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25473 int arg2 ;
25474 void *argp1 = 0 ;
25475 int res1 = 0 ;
25476 int val2 ;
25477 int ecode2 = 0 ;
25478 PyObject *swig_obj[2] ;
25479
25480 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25484 }
25485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25486 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25487 if (!SWIG_IsOK(ecode2)) {
25488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25489 }
25490 arg2 = static_cast< int >(val2);
25491 if (arg1) (arg1)->m_y = arg2;
25492
25493 resultobj = SWIG_Py_Void();
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501 PyObject *resultobj = 0;
25502 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25503 int result;
25504 void *argp1 = 0 ;
25505 int res1 = 0 ;
25506 PyObject *swig_obj[1] ;
25507
25508 if (!args) SWIG_fail;
25509 swig_obj[0] = args;
25510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25513 }
25514 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25515 result = (int) ((arg1)->m_y);
25516 resultobj = SWIG_From_int(static_cast< int >(result));
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25524 PyObject *resultobj = 0;
25525 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25526 long arg2 ;
25527 void *argp1 = 0 ;
25528 int res1 = 0 ;
25529 long val2 ;
25530 int ecode2 = 0 ;
25531 PyObject *swig_obj[2] ;
25532
25533 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25535 if (!SWIG_IsOK(res1)) {
25536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25537 }
25538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25539 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25540 if (!SWIG_IsOK(ecode2)) {
25541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25542 }
25543 arg2 = static_cast< long >(val2);
25544 if (arg1) (arg1)->m_keyCode = arg2;
25545
25546 resultobj = SWIG_Py_Void();
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 PyObject *resultobj = 0;
25555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25556 long result;
25557 void *argp1 = 0 ;
25558 int res1 = 0 ;
25559 PyObject *swig_obj[1] ;
25560
25561 if (!args) SWIG_fail;
25562 swig_obj[0] = args;
25563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25564 if (!SWIG_IsOK(res1)) {
25565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25566 }
25567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25568 result = (long) ((arg1)->m_keyCode);
25569 resultobj = SWIG_From_long(static_cast< long >(result));
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25577 PyObject *resultobj = 0;
25578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25579 bool arg2 ;
25580 void *argp1 = 0 ;
25581 int res1 = 0 ;
25582 bool val2 ;
25583 int ecode2 = 0 ;
25584 PyObject *swig_obj[2] ;
25585
25586 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25588 if (!SWIG_IsOK(res1)) {
25589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25590 }
25591 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25592 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25593 if (!SWIG_IsOK(ecode2)) {
25594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25595 }
25596 arg2 = static_cast< bool >(val2);
25597 if (arg1) (arg1)->m_controlDown = arg2;
25598
25599 resultobj = SWIG_Py_Void();
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25607 PyObject *resultobj = 0;
25608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25609 bool result;
25610 void *argp1 = 0 ;
25611 int res1 = 0 ;
25612 PyObject *swig_obj[1] ;
25613
25614 if (!args) SWIG_fail;
25615 swig_obj[0] = args;
25616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25617 if (!SWIG_IsOK(res1)) {
25618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25619 }
25620 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25621 result = (bool) ((arg1)->m_controlDown);
25622 {
25623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25632 PyObject *resultobj = 0;
25633 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25634 bool arg2 ;
25635 void *argp1 = 0 ;
25636 int res1 = 0 ;
25637 bool val2 ;
25638 int ecode2 = 0 ;
25639 PyObject *swig_obj[2] ;
25640
25641 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25643 if (!SWIG_IsOK(res1)) {
25644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25645 }
25646 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25647 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25648 if (!SWIG_IsOK(ecode2)) {
25649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25650 }
25651 arg2 = static_cast< bool >(val2);
25652 if (arg1) (arg1)->m_shiftDown = arg2;
25653
25654 resultobj = SWIG_Py_Void();
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25662 PyObject *resultobj = 0;
25663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25664 bool result;
25665 void *argp1 = 0 ;
25666 int res1 = 0 ;
25667 PyObject *swig_obj[1] ;
25668
25669 if (!args) SWIG_fail;
25670 swig_obj[0] = args;
25671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25672 if (!SWIG_IsOK(res1)) {
25673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25674 }
25675 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25676 result = (bool) ((arg1)->m_shiftDown);
25677 {
25678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25679 }
25680 return resultobj;
25681 fail:
25682 return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25687 PyObject *resultobj = 0;
25688 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25689 bool arg2 ;
25690 void *argp1 = 0 ;
25691 int res1 = 0 ;
25692 bool val2 ;
25693 int ecode2 = 0 ;
25694 PyObject *swig_obj[2] ;
25695
25696 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25698 if (!SWIG_IsOK(res1)) {
25699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25700 }
25701 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25702 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25703 if (!SWIG_IsOK(ecode2)) {
25704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25705 }
25706 arg2 = static_cast< bool >(val2);
25707 if (arg1) (arg1)->m_altDown = arg2;
25708
25709 resultobj = SWIG_Py_Void();
25710 return resultobj;
25711 fail:
25712 return NULL;
25713 }
25714
25715
25716 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25717 PyObject *resultobj = 0;
25718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25719 bool result;
25720 void *argp1 = 0 ;
25721 int res1 = 0 ;
25722 PyObject *swig_obj[1] ;
25723
25724 if (!args) SWIG_fail;
25725 swig_obj[0] = args;
25726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25727 if (!SWIG_IsOK(res1)) {
25728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25729 }
25730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25731 result = (bool) ((arg1)->m_altDown);
25732 {
25733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25734 }
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25742 PyObject *resultobj = 0;
25743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25744 bool arg2 ;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 bool val2 ;
25748 int ecode2 = 0 ;
25749 PyObject *swig_obj[2] ;
25750
25751 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25753 if (!SWIG_IsOK(res1)) {
25754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25755 }
25756 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25757 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25758 if (!SWIG_IsOK(ecode2)) {
25759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25760 }
25761 arg2 = static_cast< bool >(val2);
25762 if (arg1) (arg1)->m_metaDown = arg2;
25763
25764 resultobj = SWIG_Py_Void();
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25772 PyObject *resultobj = 0;
25773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25774 bool result;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 PyObject *swig_obj[1] ;
25778
25779 if (!args) SWIG_fail;
25780 swig_obj[0] = args;
25781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25782 if (!SWIG_IsOK(res1)) {
25783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25784 }
25785 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25786 result = (bool) ((arg1)->m_metaDown);
25787 {
25788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25797 PyObject *resultobj = 0;
25798 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25799 bool arg2 ;
25800 void *argp1 = 0 ;
25801 int res1 = 0 ;
25802 bool val2 ;
25803 int ecode2 = 0 ;
25804 PyObject *swig_obj[2] ;
25805
25806 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25810 }
25811 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25812 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25813 if (!SWIG_IsOK(ecode2)) {
25814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25815 }
25816 arg2 = static_cast< bool >(val2);
25817 if (arg1) (arg1)->m_scanCode = arg2;
25818
25819 resultobj = SWIG_Py_Void();
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25827 PyObject *resultobj = 0;
25828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25829 bool result;
25830 void *argp1 = 0 ;
25831 int res1 = 0 ;
25832 PyObject *swig_obj[1] ;
25833
25834 if (!args) SWIG_fail;
25835 swig_obj[0] = args;
25836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25837 if (!SWIG_IsOK(res1)) {
25838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25839 }
25840 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25841 result = (bool) ((arg1)->m_scanCode);
25842 {
25843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25844 }
25845 return resultobj;
25846 fail:
25847 return NULL;
25848 }
25849
25850
25851 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25852 PyObject *resultobj = 0;
25853 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25854 unsigned int arg2 ;
25855 void *argp1 = 0 ;
25856 int res1 = 0 ;
25857 unsigned int val2 ;
25858 int ecode2 = 0 ;
25859 PyObject *swig_obj[2] ;
25860
25861 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25863 if (!SWIG_IsOK(res1)) {
25864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25865 }
25866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25867 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25868 if (!SWIG_IsOK(ecode2)) {
25869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25870 }
25871 arg2 = static_cast< unsigned int >(val2);
25872 if (arg1) (arg1)->m_rawCode = arg2;
25873
25874 resultobj = SWIG_Py_Void();
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25882 PyObject *resultobj = 0;
25883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25884 unsigned int result;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 PyObject *swig_obj[1] ;
25888
25889 if (!args) SWIG_fail;
25890 swig_obj[0] = args;
25891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25892 if (!SWIG_IsOK(res1)) {
25893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25894 }
25895 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25896 result = (unsigned int) ((arg1)->m_rawCode);
25897 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25898 return resultobj;
25899 fail:
25900 return NULL;
25901 }
25902
25903
25904 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25905 PyObject *resultobj = 0;
25906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25907 unsigned int arg2 ;
25908 void *argp1 = 0 ;
25909 int res1 = 0 ;
25910 unsigned int val2 ;
25911 int ecode2 = 0 ;
25912 PyObject *swig_obj[2] ;
25913
25914 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25916 if (!SWIG_IsOK(res1)) {
25917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25918 }
25919 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25920 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25921 if (!SWIG_IsOK(ecode2)) {
25922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25923 }
25924 arg2 = static_cast< unsigned int >(val2);
25925 if (arg1) (arg1)->m_rawFlags = arg2;
25926
25927 resultobj = SWIG_Py_Void();
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25935 PyObject *resultobj = 0;
25936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25937 unsigned int result;
25938 void *argp1 = 0 ;
25939 int res1 = 0 ;
25940 PyObject *swig_obj[1] ;
25941
25942 if (!args) SWIG_fail;
25943 swig_obj[0] = args;
25944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25947 }
25948 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25949 result = (unsigned int) ((arg1)->m_rawFlags);
25950 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 PyObject *obj;
25959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25960 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25961 return SWIG_Py_Void();
25962 }
25963
25964 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25965 return SWIG_Python_InitShadowInstance(args);
25966 }
25967
25968 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj = 0;
25970 wxSize const &arg1_defvalue = wxDefaultSize ;
25971 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25972 int arg2 = (int) 0 ;
25973 wxSizeEvent *result = 0 ;
25974 wxSize temp1 ;
25975 int val2 ;
25976 int ecode2 = 0 ;
25977 PyObject * obj0 = 0 ;
25978 PyObject * obj1 = 0 ;
25979 char * kwnames[] = {
25980 (char *) "sz",(char *) "winid", NULL
25981 };
25982
25983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25984 if (obj0) {
25985 {
25986 arg1 = &temp1;
25987 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25988 }
25989 }
25990 if (obj1) {
25991 ecode2 = SWIG_AsVal_int(obj1, &val2);
25992 if (!SWIG_IsOK(ecode2)) {
25993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25994 }
25995 arg2 = static_cast< int >(val2);
25996 }
25997 {
25998 PyThreadState* __tstate = wxPyBeginAllowThreads();
25999 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26011 PyObject *resultobj = 0;
26012 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26013 wxSize result;
26014 void *argp1 = 0 ;
26015 int res1 = 0 ;
26016 PyObject *swig_obj[1] ;
26017
26018 if (!args) SWIG_fail;
26019 swig_obj[0] = args;
26020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26021 if (!SWIG_IsOK(res1)) {
26022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26023 }
26024 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26025 {
26026 PyThreadState* __tstate = wxPyBeginAllowThreads();
26027 result = ((wxSizeEvent const *)arg1)->GetSize();
26028 wxPyEndAllowThreads(__tstate);
26029 if (PyErr_Occurred()) SWIG_fail;
26030 }
26031 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26039 PyObject *resultobj = 0;
26040 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26041 wxRect result;
26042 void *argp1 = 0 ;
26043 int res1 = 0 ;
26044 PyObject *swig_obj[1] ;
26045
26046 if (!args) SWIG_fail;
26047 swig_obj[0] = args;
26048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26049 if (!SWIG_IsOK(res1)) {
26050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26051 }
26052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 result = ((wxSizeEvent const *)arg1)->GetRect();
26056 wxPyEndAllowThreads(__tstate);
26057 if (PyErr_Occurred()) SWIG_fail;
26058 }
26059 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26060 return resultobj;
26061 fail:
26062 return NULL;
26063 }
26064
26065
26066 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26067 PyObject *resultobj = 0;
26068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26069 wxRect arg2 ;
26070 void *argp1 = 0 ;
26071 int res1 = 0 ;
26072 void *argp2 ;
26073 int res2 = 0 ;
26074 PyObject * obj0 = 0 ;
26075 PyObject * obj1 = 0 ;
26076 char * kwnames[] = {
26077 (char *) "self",(char *) "rect", NULL
26078 };
26079
26080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26082 if (!SWIG_IsOK(res1)) {
26083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26084 }
26085 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26086 {
26087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26088 if (!SWIG_IsOK(res2)) {
26089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26090 }
26091 if (!argp2) {
26092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26093 } else {
26094 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26095 arg2 = *temp;
26096 if (SWIG_IsNewObj(res2)) delete temp;
26097 }
26098 }
26099 {
26100 PyThreadState* __tstate = wxPyBeginAllowThreads();
26101 (arg1)->SetRect(arg2);
26102 wxPyEndAllowThreads(__tstate);
26103 if (PyErr_Occurred()) SWIG_fail;
26104 }
26105 resultobj = SWIG_Py_Void();
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26113 PyObject *resultobj = 0;
26114 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26115 wxSize arg2 ;
26116 void *argp1 = 0 ;
26117 int res1 = 0 ;
26118 void *argp2 ;
26119 int res2 = 0 ;
26120 PyObject * obj0 = 0 ;
26121 PyObject * obj1 = 0 ;
26122 char * kwnames[] = {
26123 (char *) "self",(char *) "size", NULL
26124 };
26125
26126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26128 if (!SWIG_IsOK(res1)) {
26129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26130 }
26131 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26132 {
26133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26134 if (!SWIG_IsOK(res2)) {
26135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26136 }
26137 if (!argp2) {
26138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26139 } else {
26140 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26141 arg2 = *temp;
26142 if (SWIG_IsNewObj(res2)) delete temp;
26143 }
26144 }
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 wxSizeEvent_SetSize(arg1,arg2);
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 resultobj = SWIG_Py_Void();
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26159 PyObject *resultobj = 0;
26160 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26161 wxSize *arg2 = (wxSize *) 0 ;
26162 void *argp1 = 0 ;
26163 int res1 = 0 ;
26164 void *argp2 = 0 ;
26165 int res2 = 0 ;
26166 PyObject *swig_obj[2] ;
26167
26168 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26174 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26175 if (!SWIG_IsOK(res2)) {
26176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26177 }
26178 arg2 = reinterpret_cast< wxSize * >(argp2);
26179 if (arg1) (arg1)->m_size = *arg2;
26180
26181 resultobj = SWIG_Py_Void();
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26189 PyObject *resultobj = 0;
26190 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26191 wxSize *result = 0 ;
26192 void *argp1 = 0 ;
26193 int res1 = 0 ;
26194 PyObject *swig_obj[1] ;
26195
26196 if (!args) SWIG_fail;
26197 swig_obj[0] = args;
26198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26201 }
26202 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26203 result = (wxSize *)& ((arg1)->m_size);
26204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26212 PyObject *resultobj = 0;
26213 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26214 wxRect *arg2 = (wxRect *) 0 ;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 void *argp2 = 0 ;
26218 int res2 = 0 ;
26219 PyObject *swig_obj[2] ;
26220
26221 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26225 }
26226 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26227 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26228 if (!SWIG_IsOK(res2)) {
26229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26230 }
26231 arg2 = reinterpret_cast< wxRect * >(argp2);
26232 if (arg1) (arg1)->m_rect = *arg2;
26233
26234 resultobj = SWIG_Py_Void();
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26242 PyObject *resultobj = 0;
26243 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26244 wxRect *result = 0 ;
26245 void *argp1 = 0 ;
26246 int res1 = 0 ;
26247 PyObject *swig_obj[1] ;
26248
26249 if (!args) SWIG_fail;
26250 swig_obj[0] = args;
26251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26252 if (!SWIG_IsOK(res1)) {
26253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26254 }
26255 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26256 result = (wxRect *)& ((arg1)->m_rect);
26257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26258 return resultobj;
26259 fail:
26260 return NULL;
26261 }
26262
26263
26264 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26265 PyObject *obj;
26266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26267 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26268 return SWIG_Py_Void();
26269 }
26270
26271 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26272 return SWIG_Python_InitShadowInstance(args);
26273 }
26274
26275 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26276 PyObject *resultobj = 0;
26277 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26278 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26279 int arg2 = (int) 0 ;
26280 wxMoveEvent *result = 0 ;
26281 wxPoint temp1 ;
26282 int val2 ;
26283 int ecode2 = 0 ;
26284 PyObject * obj0 = 0 ;
26285 PyObject * obj1 = 0 ;
26286 char * kwnames[] = {
26287 (char *) "pos",(char *) "winid", NULL
26288 };
26289
26290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26291 if (obj0) {
26292 {
26293 arg1 = &temp1;
26294 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26295 }
26296 }
26297 if (obj1) {
26298 ecode2 = SWIG_AsVal_int(obj1, &val2);
26299 if (!SWIG_IsOK(ecode2)) {
26300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26301 }
26302 arg2 = static_cast< int >(val2);
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 PyObject *resultobj = 0;
26319 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26320 wxPoint result;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 PyObject *swig_obj[1] ;
26324
26325 if (!args) SWIG_fail;
26326 swig_obj[0] = args;
26327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26330 }
26331 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = ((wxMoveEvent const *)arg1)->GetPosition();
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26346 PyObject *resultobj = 0;
26347 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26348 wxRect result;
26349 void *argp1 = 0 ;
26350 int res1 = 0 ;
26351 PyObject *swig_obj[1] ;
26352
26353 if (!args) SWIG_fail;
26354 swig_obj[0] = args;
26355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26356 if (!SWIG_IsOK(res1)) {
26357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26358 }
26359 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = ((wxMoveEvent const *)arg1)->GetRect();
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26376 wxRect *arg2 = 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 wxRect temp2 ;
26380 PyObject * obj0 = 0 ;
26381 PyObject * obj1 = 0 ;
26382 char * kwnames[] = {
26383 (char *) "self",(char *) "rect", NULL
26384 };
26385
26386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26390 }
26391 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26392 {
26393 arg2 = &temp2;
26394 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 (arg1)->SetRect((wxRect const &)*arg2);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 resultobj = SWIG_Py_Void();
26403 return resultobj;
26404 fail:
26405 return NULL;
26406 }
26407
26408
26409 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj = 0;
26411 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26412 wxPoint *arg2 = 0 ;
26413 void *argp1 = 0 ;
26414 int res1 = 0 ;
26415 wxPoint temp2 ;
26416 PyObject * obj0 = 0 ;
26417 PyObject * obj1 = 0 ;
26418 char * kwnames[] = {
26419 (char *) "self",(char *) "pos", NULL
26420 };
26421
26422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26424 if (!SWIG_IsOK(res1)) {
26425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26426 }
26427 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26428 {
26429 arg2 = &temp2;
26430 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26431 }
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 (arg1)->SetPosition((wxPoint const &)*arg2);
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 resultobj = SWIG_Py_Void();
26439 return resultobj;
26440 fail:
26441 return NULL;
26442 }
26443
26444
26445 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26446 PyObject *obj;
26447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26448 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26449 return SWIG_Py_Void();
26450 }
26451
26452 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26453 return SWIG_Python_InitShadowInstance(args);
26454 }
26455
26456 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj = 0;
26458 int arg1 = (int) 0 ;
26459 wxPaintEvent *result = 0 ;
26460 int val1 ;
26461 int ecode1 = 0 ;
26462 PyObject * obj0 = 0 ;
26463 char * kwnames[] = {
26464 (char *) "Id", NULL
26465 };
26466
26467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26468 if (obj0) {
26469 ecode1 = SWIG_AsVal_int(obj0, &val1);
26470 if (!SWIG_IsOK(ecode1)) {
26471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26472 }
26473 arg1 = static_cast< int >(val1);
26474 }
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26478 wxPyEndAllowThreads(__tstate);
26479 if (PyErr_Occurred()) SWIG_fail;
26480 }
26481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26489 PyObject *obj;
26490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26491 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26492 return SWIG_Py_Void();
26493 }
26494
26495 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26496 return SWIG_Python_InitShadowInstance(args);
26497 }
26498
26499 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj = 0;
26501 int arg1 = (int) 0 ;
26502 wxNcPaintEvent *result = 0 ;
26503 int val1 ;
26504 int ecode1 = 0 ;
26505 PyObject * obj0 = 0 ;
26506 char * kwnames[] = {
26507 (char *) "winid", NULL
26508 };
26509
26510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26511 if (obj0) {
26512 ecode1 = SWIG_AsVal_int(obj0, &val1);
26513 if (!SWIG_IsOK(ecode1)) {
26514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26515 }
26516 arg1 = static_cast< int >(val1);
26517 }
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26532 PyObject *obj;
26533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26534 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26535 return SWIG_Py_Void();
26536 }
26537
26538 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26539 return SWIG_Python_InitShadowInstance(args);
26540 }
26541
26542 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26543 PyObject *resultobj = 0;
26544 int arg1 = (int) 0 ;
26545 wxDC *arg2 = (wxDC *) NULL ;
26546 wxEraseEvent *result = 0 ;
26547 int val1 ;
26548 int ecode1 = 0 ;
26549 void *argp2 = 0 ;
26550 int res2 = 0 ;
26551 PyObject * obj0 = 0 ;
26552 PyObject * obj1 = 0 ;
26553 char * kwnames[] = {
26554 (char *) "Id",(char *) "dc", NULL
26555 };
26556
26557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26558 if (obj0) {
26559 ecode1 = SWIG_AsVal_int(obj0, &val1);
26560 if (!SWIG_IsOK(ecode1)) {
26561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26562 }
26563 arg1 = static_cast< int >(val1);
26564 }
26565 if (obj1) {
26566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26567 if (!SWIG_IsOK(res2)) {
26568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26569 }
26570 arg2 = reinterpret_cast< wxDC * >(argp2);
26571 }
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26575 wxPyEndAllowThreads(__tstate);
26576 if (PyErr_Occurred()) SWIG_fail;
26577 }
26578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26579 return resultobj;
26580 fail:
26581 return NULL;
26582 }
26583
26584
26585 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26586 PyObject *resultobj = 0;
26587 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26588 wxDC *result = 0 ;
26589 void *argp1 = 0 ;
26590 int res1 = 0 ;
26591 PyObject *swig_obj[1] ;
26592
26593 if (!args) SWIG_fail;
26594 swig_obj[0] = args;
26595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26596 if (!SWIG_IsOK(res1)) {
26597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26598 }
26599 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 {
26607 resultobj = wxPyMake_wxObject(result, (bool)0);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26616 PyObject *obj;
26617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26618 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26619 return SWIG_Py_Void();
26620 }
26621
26622 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 return SWIG_Python_InitShadowInstance(args);
26624 }
26625
26626 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26627 PyObject *resultobj = 0;
26628 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26629 int arg2 = (int) 0 ;
26630 wxFocusEvent *result = 0 ;
26631 int val1 ;
26632 int ecode1 = 0 ;
26633 int val2 ;
26634 int ecode2 = 0 ;
26635 PyObject * obj0 = 0 ;
26636 PyObject * obj1 = 0 ;
26637 char * kwnames[] = {
26638 (char *) "type",(char *) "winid", NULL
26639 };
26640
26641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26642 if (obj0) {
26643 ecode1 = SWIG_AsVal_int(obj0, &val1);
26644 if (!SWIG_IsOK(ecode1)) {
26645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26646 }
26647 arg1 = static_cast< wxEventType >(val1);
26648 }
26649 if (obj1) {
26650 ecode2 = SWIG_AsVal_int(obj1, &val2);
26651 if (!SWIG_IsOK(ecode2)) {
26652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26653 }
26654 arg2 = static_cast< int >(val2);
26655 }
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26670 PyObject *resultobj = 0;
26671 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26672 wxWindow *result = 0 ;
26673 void *argp1 = 0 ;
26674 int res1 = 0 ;
26675 PyObject *swig_obj[1] ;
26676
26677 if (!args) SWIG_fail;
26678 swig_obj[0] = args;
26679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26682 }
26683 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 {
26691 resultobj = wxPyMake_wxObject(result, (bool)0);
26692 }
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = 0;
26701 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26702 wxWindow *arg2 = (wxWindow *) 0 ;
26703 void *argp1 = 0 ;
26704 int res1 = 0 ;
26705 void *argp2 = 0 ;
26706 int res2 = 0 ;
26707 PyObject * obj0 = 0 ;
26708 PyObject * obj1 = 0 ;
26709 char * kwnames[] = {
26710 (char *) "self",(char *) "win", NULL
26711 };
26712
26713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26715 if (!SWIG_IsOK(res1)) {
26716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26717 }
26718 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26720 if (!SWIG_IsOK(res2)) {
26721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26722 }
26723 arg2 = reinterpret_cast< wxWindow * >(argp2);
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 (arg1)->SetWindow(arg2);
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 resultobj = SWIG_Py_Void();
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26738 PyObject *obj;
26739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26740 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26741 return SWIG_Py_Void();
26742 }
26743
26744 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 return SWIG_Python_InitShadowInstance(args);
26746 }
26747
26748 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj = 0;
26750 wxWindow *arg1 = (wxWindow *) NULL ;
26751 wxChildFocusEvent *result = 0 ;
26752 void *argp1 = 0 ;
26753 int res1 = 0 ;
26754 PyObject * obj0 = 0 ;
26755 char * kwnames[] = {
26756 (char *) "win", NULL
26757 };
26758
26759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26760 if (obj0) {
26761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26762 if (!SWIG_IsOK(res1)) {
26763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26764 }
26765 arg1 = reinterpret_cast< wxWindow * >(argp1);
26766 }
26767 {
26768 PyThreadState* __tstate = wxPyBeginAllowThreads();
26769 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26770 wxPyEndAllowThreads(__tstate);
26771 if (PyErr_Occurred()) SWIG_fail;
26772 }
26773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26774 return resultobj;
26775 fail:
26776 return NULL;
26777 }
26778
26779
26780 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26781 PyObject *resultobj = 0;
26782 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26783 wxWindow *result = 0 ;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 PyObject *swig_obj[1] ;
26787
26788 if (!args) SWIG_fail;
26789 swig_obj[0] = args;
26790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26791 if (!SWIG_IsOK(res1)) {
26792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26793 }
26794 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26795 {
26796 PyThreadState* __tstate = wxPyBeginAllowThreads();
26797 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 {
26802 resultobj = wxPyMake_wxObject(result, (bool)0);
26803 }
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26811 PyObject *obj;
26812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26813 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26814 return SWIG_Py_Void();
26815 }
26816
26817 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26818 return SWIG_Python_InitShadowInstance(args);
26819 }
26820
26821 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26822 PyObject *resultobj = 0;
26823 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26824 bool arg2 = (bool) true ;
26825 int arg3 = (int) 0 ;
26826 wxActivateEvent *result = 0 ;
26827 int val1 ;
26828 int ecode1 = 0 ;
26829 bool val2 ;
26830 int ecode2 = 0 ;
26831 int val3 ;
26832 int ecode3 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 PyObject * obj2 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "type",(char *) "active",(char *) "Id", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26841 if (obj0) {
26842 ecode1 = SWIG_AsVal_int(obj0, &val1);
26843 if (!SWIG_IsOK(ecode1)) {
26844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26845 }
26846 arg1 = static_cast< wxEventType >(val1);
26847 }
26848 if (obj1) {
26849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26850 if (!SWIG_IsOK(ecode2)) {
26851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26852 }
26853 arg2 = static_cast< bool >(val2);
26854 }
26855 if (obj2) {
26856 ecode3 = SWIG_AsVal_int(obj2, &val3);
26857 if (!SWIG_IsOK(ecode3)) {
26858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26859 }
26860 arg3 = static_cast< int >(val3);
26861 }
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26876 PyObject *resultobj = 0;
26877 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26878 bool result;
26879 void *argp1 = 0 ;
26880 int res1 = 0 ;
26881 PyObject *swig_obj[1] ;
26882
26883 if (!args) SWIG_fail;
26884 swig_obj[0] = args;
26885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26886 if (!SWIG_IsOK(res1)) {
26887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26888 }
26889 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26890 {
26891 PyThreadState* __tstate = wxPyBeginAllowThreads();
26892 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26893 wxPyEndAllowThreads(__tstate);
26894 if (PyErr_Occurred()) SWIG_fail;
26895 }
26896 {
26897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26898 }
26899 return resultobj;
26900 fail:
26901 return NULL;
26902 }
26903
26904
26905 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26906 PyObject *obj;
26907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26908 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26909 return SWIG_Py_Void();
26910 }
26911
26912 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26913 return SWIG_Python_InitShadowInstance(args);
26914 }
26915
26916 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj = 0;
26918 int arg1 = (int) 0 ;
26919 wxInitDialogEvent *result = 0 ;
26920 int val1 ;
26921 int ecode1 = 0 ;
26922 PyObject * obj0 = 0 ;
26923 char * kwnames[] = {
26924 (char *) "Id", NULL
26925 };
26926
26927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26928 if (obj0) {
26929 ecode1 = SWIG_AsVal_int(obj0, &val1);
26930 if (!SWIG_IsOK(ecode1)) {
26931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26932 }
26933 arg1 = static_cast< int >(val1);
26934 }
26935 {
26936 PyThreadState* __tstate = wxPyBeginAllowThreads();
26937 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26938 wxPyEndAllowThreads(__tstate);
26939 if (PyErr_Occurred()) SWIG_fail;
26940 }
26941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26949 PyObject *obj;
26950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26951 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26952 return SWIG_Py_Void();
26953 }
26954
26955 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 return SWIG_Python_InitShadowInstance(args);
26957 }
26958
26959 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj = 0;
26961 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26962 int arg2 = (int) 0 ;
26963 wxMenu *arg3 = (wxMenu *) NULL ;
26964 wxMenuEvent *result = 0 ;
26965 int val1 ;
26966 int ecode1 = 0 ;
26967 int val2 ;
26968 int ecode2 = 0 ;
26969 void *argp3 = 0 ;
26970 int res3 = 0 ;
26971 PyObject * obj0 = 0 ;
26972 PyObject * obj1 = 0 ;
26973 PyObject * obj2 = 0 ;
26974 char * kwnames[] = {
26975 (char *) "type",(char *) "winid",(char *) "menu", NULL
26976 };
26977
26978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26979 if (obj0) {
26980 ecode1 = SWIG_AsVal_int(obj0, &val1);
26981 if (!SWIG_IsOK(ecode1)) {
26982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26983 }
26984 arg1 = static_cast< wxEventType >(val1);
26985 }
26986 if (obj1) {
26987 ecode2 = SWIG_AsVal_int(obj1, &val2);
26988 if (!SWIG_IsOK(ecode2)) {
26989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26990 }
26991 arg2 = static_cast< int >(val2);
26992 }
26993 if (obj2) {
26994 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26995 if (!SWIG_IsOK(res3)) {
26996 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26997 }
26998 arg3 = reinterpret_cast< wxMenu * >(argp3);
26999 }
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27007 return resultobj;
27008 fail:
27009 return NULL;
27010 }
27011
27012
27013 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27014 PyObject *resultobj = 0;
27015 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27016 int result;
27017 void *argp1 = 0 ;
27018 int res1 = 0 ;
27019 PyObject *swig_obj[1] ;
27020
27021 if (!args) SWIG_fail;
27022 swig_obj[0] = args;
27023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27024 if (!SWIG_IsOK(res1)) {
27025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27026 }
27027 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27028 {
27029 PyThreadState* __tstate = wxPyBeginAllowThreads();
27030 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 resultobj = SWIG_From_int(static_cast< int >(result));
27035 return resultobj;
27036 fail:
27037 return NULL;
27038 }
27039
27040
27041 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 PyObject *resultobj = 0;
27043 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27044 bool result;
27045 void *argp1 = 0 ;
27046 int res1 = 0 ;
27047 PyObject *swig_obj[1] ;
27048
27049 if (!args) SWIG_fail;
27050 swig_obj[0] = args;
27051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27052 if (!SWIG_IsOK(res1)) {
27053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27054 }
27055 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 {
27063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27064 }
27065 return resultobj;
27066 fail:
27067 return NULL;
27068 }
27069
27070
27071 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27072 PyObject *resultobj = 0;
27073 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27074 wxMenu *result = 0 ;
27075 void *argp1 = 0 ;
27076 int res1 = 0 ;
27077 PyObject *swig_obj[1] ;
27078
27079 if (!args) SWIG_fail;
27080 swig_obj[0] = args;
27081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27082 if (!SWIG_IsOK(res1)) {
27083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27084 }
27085 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = wxPyMake_wxObject(result, (bool)0);
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *obj;
27103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27104 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27105 return SWIG_Py_Void();
27106 }
27107
27108 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27109 return SWIG_Python_InitShadowInstance(args);
27110 }
27111
27112 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27115 int arg2 = (int) 0 ;
27116 wxCloseEvent *result = 0 ;
27117 int val1 ;
27118 int ecode1 = 0 ;
27119 int val2 ;
27120 int ecode2 = 0 ;
27121 PyObject * obj0 = 0 ;
27122 PyObject * obj1 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "type",(char *) "winid", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27128 if (obj0) {
27129 ecode1 = SWIG_AsVal_int(obj0, &val1);
27130 if (!SWIG_IsOK(ecode1)) {
27131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27132 }
27133 arg1 = static_cast< wxEventType >(val1);
27134 }
27135 if (obj1) {
27136 ecode2 = SWIG_AsVal_int(obj1, &val2);
27137 if (!SWIG_IsOK(ecode2)) {
27138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27139 }
27140 arg2 = static_cast< int >(val2);
27141 }
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27156 PyObject *resultobj = 0;
27157 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27158 bool arg2 ;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 bool val2 ;
27162 int ecode2 = 0 ;
27163 PyObject * obj0 = 0 ;
27164 PyObject * obj1 = 0 ;
27165 char * kwnames[] = {
27166 (char *) "self",(char *) "logOff", NULL
27167 };
27168
27169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27171 if (!SWIG_IsOK(res1)) {
27172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27173 }
27174 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27176 if (!SWIG_IsOK(ecode2)) {
27177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27178 }
27179 arg2 = static_cast< bool >(val2);
27180 {
27181 PyThreadState* __tstate = wxPyBeginAllowThreads();
27182 (arg1)->SetLoggingOff(arg2);
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 resultobj = SWIG_Py_Void();
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27194 PyObject *resultobj = 0;
27195 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27196 bool result;
27197 void *argp1 = 0 ;
27198 int res1 = 0 ;
27199 PyObject *swig_obj[1] ;
27200
27201 if (!args) SWIG_fail;
27202 swig_obj[0] = args;
27203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27206 }
27207 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 {
27215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj = 0;
27225 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27226 bool arg2 = (bool) true ;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 bool val2 ;
27230 int ecode2 = 0 ;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 char * kwnames[] = {
27234 (char *) "self",(char *) "veto", NULL
27235 };
27236
27237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27239 if (!SWIG_IsOK(res1)) {
27240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27241 }
27242 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27243 if (obj1) {
27244 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27245 if (!SWIG_IsOK(ecode2)) {
27246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27247 }
27248 arg2 = static_cast< bool >(val2);
27249 }
27250 {
27251 PyThreadState* __tstate = wxPyBeginAllowThreads();
27252 (arg1)->Veto(arg2);
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 resultobj = SWIG_Py_Void();
27257 return resultobj;
27258 fail:
27259 return NULL;
27260 }
27261
27262
27263 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27264 PyObject *resultobj = 0;
27265 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27266 bool result;
27267 void *argp1 = 0 ;
27268 int res1 = 0 ;
27269 PyObject *swig_obj[1] ;
27270
27271 if (!args) SWIG_fail;
27272 swig_obj[0] = args;
27273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27274 if (!SWIG_IsOK(res1)) {
27275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27276 }
27277 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 {
27285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj = 0;
27295 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27296 bool arg2 ;
27297 void *argp1 = 0 ;
27298 int res1 = 0 ;
27299 bool val2 ;
27300 int ecode2 = 0 ;
27301 PyObject * obj0 = 0 ;
27302 PyObject * obj1 = 0 ;
27303 char * kwnames[] = {
27304 (char *) "self",(char *) "canVeto", NULL
27305 };
27306
27307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27309 if (!SWIG_IsOK(res1)) {
27310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27311 }
27312 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27313 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27314 if (!SWIG_IsOK(ecode2)) {
27315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27316 }
27317 arg2 = static_cast< bool >(val2);
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->SetCanVeto(arg2);
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 resultobj = SWIG_Py_Void();
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27332 PyObject *resultobj = 0;
27333 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27334 bool result;
27335 void *argp1 = 0 ;
27336 int res1 = 0 ;
27337 PyObject *swig_obj[1] ;
27338
27339 if (!args) SWIG_fail;
27340 swig_obj[0] = args;
27341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27344 }
27345 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 {
27353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27354 }
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27362 PyObject *obj;
27363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27364 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27365 return SWIG_Py_Void();
27366 }
27367
27368 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27369 return SWIG_Python_InitShadowInstance(args);
27370 }
27371
27372 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj = 0;
27374 int arg1 = (int) 0 ;
27375 bool arg2 = (bool) false ;
27376 wxShowEvent *result = 0 ;
27377 int val1 ;
27378 int ecode1 = 0 ;
27379 bool val2 ;
27380 int ecode2 = 0 ;
27381 PyObject * obj0 = 0 ;
27382 PyObject * obj1 = 0 ;
27383 char * kwnames[] = {
27384 (char *) "winid",(char *) "show", NULL
27385 };
27386
27387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27388 if (obj0) {
27389 ecode1 = SWIG_AsVal_int(obj0, &val1);
27390 if (!SWIG_IsOK(ecode1)) {
27391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27392 }
27393 arg1 = static_cast< int >(val1);
27394 }
27395 if (obj1) {
27396 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27397 if (!SWIG_IsOK(ecode2)) {
27398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27399 }
27400 arg2 = static_cast< bool >(val2);
27401 }
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj = 0;
27417 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27418 bool arg2 ;
27419 void *argp1 = 0 ;
27420 int res1 = 0 ;
27421 bool val2 ;
27422 int ecode2 = 0 ;
27423 PyObject * obj0 = 0 ;
27424 PyObject * obj1 = 0 ;
27425 char * kwnames[] = {
27426 (char *) "self",(char *) "show", NULL
27427 };
27428
27429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27431 if (!SWIG_IsOK(res1)) {
27432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27433 }
27434 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27436 if (!SWIG_IsOK(ecode2)) {
27437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27438 }
27439 arg2 = static_cast< bool >(val2);
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 (arg1)->SetShow(arg2);
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_Py_Void();
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27456 bool result;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27466 }
27467 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 {
27475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27476 }
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27484 PyObject *obj;
27485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27486 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27487 return SWIG_Py_Void();
27488 }
27489
27490 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27491 return SWIG_Python_InitShadowInstance(args);
27492 }
27493
27494 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj = 0;
27496 int arg1 = (int) 0 ;
27497 bool arg2 = (bool) true ;
27498 wxIconizeEvent *result = 0 ;
27499 int val1 ;
27500 int ecode1 = 0 ;
27501 bool val2 ;
27502 int ecode2 = 0 ;
27503 PyObject * obj0 = 0 ;
27504 PyObject * obj1 = 0 ;
27505 char * kwnames[] = {
27506 (char *) "id",(char *) "iconized", NULL
27507 };
27508
27509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27510 if (obj0) {
27511 ecode1 = SWIG_AsVal_int(obj0, &val1);
27512 if (!SWIG_IsOK(ecode1)) {
27513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27514 }
27515 arg1 = static_cast< int >(val1);
27516 }
27517 if (obj1) {
27518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27519 if (!SWIG_IsOK(ecode2)) {
27520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27521 }
27522 arg2 = static_cast< bool >(val2);
27523 }
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27538 PyObject *resultobj = 0;
27539 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27540 bool result;
27541 void *argp1 = 0 ;
27542 int res1 = 0 ;
27543 PyObject *swig_obj[1] ;
27544
27545 if (!args) SWIG_fail;
27546 swig_obj[0] = args;
27547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27548 if (!SWIG_IsOK(res1)) {
27549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27550 }
27551 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 result = (bool)(arg1)->Iconized();
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 {
27559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27560 }
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *obj;
27569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27570 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27571 return SWIG_Py_Void();
27572 }
27573
27574 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27575 return SWIG_Python_InitShadowInstance(args);
27576 }
27577
27578 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj = 0;
27580 int arg1 = (int) 0 ;
27581 wxMaximizeEvent *result = 0 ;
27582 int val1 ;
27583 int ecode1 = 0 ;
27584 PyObject * obj0 = 0 ;
27585 char * kwnames[] = {
27586 (char *) "id", NULL
27587 };
27588
27589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27590 if (obj0) {
27591 ecode1 = SWIG_AsVal_int(obj0, &val1);
27592 if (!SWIG_IsOK(ecode1)) {
27593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27594 }
27595 arg1 = static_cast< int >(val1);
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27604 return resultobj;
27605 fail:
27606 return NULL;
27607 }
27608
27609
27610 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27611 PyObject *obj;
27612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27613 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27614 return SWIG_Py_Void();
27615 }
27616
27617 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 return SWIG_Python_InitShadowInstance(args);
27619 }
27620
27621 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27622 PyObject *resultobj = 0;
27623 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27624 wxPoint result;
27625 void *argp1 = 0 ;
27626 int res1 = 0 ;
27627 PyObject *swig_obj[1] ;
27628
27629 if (!args) SWIG_fail;
27630 swig_obj[0] = args;
27631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27632 if (!SWIG_IsOK(res1)) {
27633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27634 }
27635 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (arg1)->GetPosition();
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 PyObject *resultobj = 0;
27651 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27652 int result;
27653 void *argp1 = 0 ;
27654 int res1 = 0 ;
27655 PyObject *swig_obj[1] ;
27656
27657 if (!args) SWIG_fail;
27658 swig_obj[0] = args;
27659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27660 if (!SWIG_IsOK(res1)) {
27661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27662 }
27663 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 result = (int)(arg1)->GetNumberOfFiles();
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_From_int(static_cast< int >(result));
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 PyObject *resultobj = 0;
27679 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27680 PyObject *result = 0 ;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 PyObject *swig_obj[1] ;
27684
27685 if (!args) SWIG_fail;
27686 swig_obj[0] = args;
27687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27690 }
27691 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 resultobj = result;
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27706 PyObject *obj;
27707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27708 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27709 return SWIG_Py_Void();
27710 }
27711
27712 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27713 PyObject *resultobj = 0;
27714 int arg1 = (int) 0 ;
27715 wxUpdateUIEvent *result = 0 ;
27716 int val1 ;
27717 int ecode1 = 0 ;
27718 PyObject * obj0 = 0 ;
27719 char * kwnames[] = {
27720 (char *) "commandId", NULL
27721 };
27722
27723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27724 if (obj0) {
27725 ecode1 = SWIG_AsVal_int(obj0, &val1);
27726 if (!SWIG_IsOK(ecode1)) {
27727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27728 }
27729 arg1 = static_cast< int >(val1);
27730 }
27731 {
27732 PyThreadState* __tstate = wxPyBeginAllowThreads();
27733 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27745 PyObject *resultobj = 0;
27746 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27747 bool result;
27748 void *argp1 = 0 ;
27749 int res1 = 0 ;
27750 PyObject *swig_obj[1] ;
27751
27752 if (!args) SWIG_fail;
27753 swig_obj[0] = args;
27754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27755 if (!SWIG_IsOK(res1)) {
27756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27757 }
27758 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 {
27766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27767 }
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27775 PyObject *resultobj = 0;
27776 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27777 bool result;
27778 void *argp1 = 0 ;
27779 int res1 = 0 ;
27780 PyObject *swig_obj[1] ;
27781
27782 if (!args) SWIG_fail;
27783 swig_obj[0] = args;
27784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27785 if (!SWIG_IsOK(res1)) {
27786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27787 }
27788 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 {
27796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27797 }
27798 return resultobj;
27799 fail:
27800 return NULL;
27801 }
27802
27803
27804 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27805 PyObject *resultobj = 0;
27806 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27807 bool result;
27808 void *argp1 = 0 ;
27809 int res1 = 0 ;
27810 PyObject *swig_obj[1] ;
27811
27812 if (!args) SWIG_fail;
27813 swig_obj[0] = args;
27814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27815 if (!SWIG_IsOK(res1)) {
27816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27817 }
27818 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27819 {
27820 PyThreadState* __tstate = wxPyBeginAllowThreads();
27821 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 {
27826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27827 }
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27835 PyObject *resultobj = 0;
27836 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27837 wxString result;
27838 void *argp1 = 0 ;
27839 int res1 = 0 ;
27840 PyObject *swig_obj[1] ;
27841
27842 if (!args) SWIG_fail;
27843 swig_obj[0] = args;
27844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27845 if (!SWIG_IsOK(res1)) {
27846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27847 }
27848 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27849 {
27850 PyThreadState* __tstate = wxPyBeginAllowThreads();
27851 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27852 wxPyEndAllowThreads(__tstate);
27853 if (PyErr_Occurred()) SWIG_fail;
27854 }
27855 {
27856 #if wxUSE_UNICODE
27857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27858 #else
27859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27860 #endif
27861 }
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27869 PyObject *resultobj = 0;
27870 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27871 bool result;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 PyObject *swig_obj[1] ;
27875
27876 if (!args) SWIG_fail;
27877 swig_obj[0] = args;
27878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27881 }
27882 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 {
27890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27891 }
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27899 PyObject *resultobj = 0;
27900 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27901 bool result;
27902 void *argp1 = 0 ;
27903 int res1 = 0 ;
27904 PyObject *swig_obj[1] ;
27905
27906 if (!args) SWIG_fail;
27907 swig_obj[0] = args;
27908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27909 if (!SWIG_IsOK(res1)) {
27910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27911 }
27912 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27913 {
27914 PyThreadState* __tstate = wxPyBeginAllowThreads();
27915 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27916 wxPyEndAllowThreads(__tstate);
27917 if (PyErr_Occurred()) SWIG_fail;
27918 }
27919 {
27920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27921 }
27922 return resultobj;
27923 fail:
27924 return NULL;
27925 }
27926
27927
27928 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27929 PyObject *resultobj = 0;
27930 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27931 bool result;
27932 void *argp1 = 0 ;
27933 int res1 = 0 ;
27934 PyObject *swig_obj[1] ;
27935
27936 if (!args) SWIG_fail;
27937 swig_obj[0] = args;
27938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27939 if (!SWIG_IsOK(res1)) {
27940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27941 }
27942 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 {
27950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27951 }
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27959 PyObject *resultobj = 0;
27960 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27961 bool result;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 PyObject *swig_obj[1] ;
27965
27966 if (!args) SWIG_fail;
27967 swig_obj[0] = args;
27968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27969 if (!SWIG_IsOK(res1)) {
27970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27971 }
27972 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 {
27980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27981 }
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj = 0;
27990 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27991 bool arg2 ;
27992 void *argp1 = 0 ;
27993 int res1 = 0 ;
27994 bool val2 ;
27995 int ecode2 = 0 ;
27996 PyObject * obj0 = 0 ;
27997 PyObject * obj1 = 0 ;
27998 char * kwnames[] = {
27999 (char *) "self",(char *) "check", NULL
28000 };
28001
28002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28004 if (!SWIG_IsOK(res1)) {
28005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28006 }
28007 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28009 if (!SWIG_IsOK(ecode2)) {
28010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28011 }
28012 arg2 = static_cast< bool >(val2);
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 (arg1)->Check(arg2);
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 resultobj = SWIG_Py_Void();
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj = 0;
28028 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28029 bool arg2 ;
28030 void *argp1 = 0 ;
28031 int res1 = 0 ;
28032 bool val2 ;
28033 int ecode2 = 0 ;
28034 PyObject * obj0 = 0 ;
28035 PyObject * obj1 = 0 ;
28036 char * kwnames[] = {
28037 (char *) "self",(char *) "enable", NULL
28038 };
28039
28040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28042 if (!SWIG_IsOK(res1)) {
28043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28044 }
28045 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28047 if (!SWIG_IsOK(ecode2)) {
28048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28049 }
28050 arg2 = static_cast< bool >(val2);
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 (arg1)->Enable(arg2);
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_Py_Void();
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28067 bool arg2 ;
28068 void *argp1 = 0 ;
28069 int res1 = 0 ;
28070 bool val2 ;
28071 int ecode2 = 0 ;
28072 PyObject * obj0 = 0 ;
28073 PyObject * obj1 = 0 ;
28074 char * kwnames[] = {
28075 (char *) "self",(char *) "show", NULL
28076 };
28077
28078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28080 if (!SWIG_IsOK(res1)) {
28081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28082 }
28083 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28084 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28085 if (!SWIG_IsOK(ecode2)) {
28086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28087 }
28088 arg2 = static_cast< bool >(val2);
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 (arg1)->Show(arg2);
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 resultobj = SWIG_Py_Void();
28096 return resultobj;
28097 fail:
28098 return NULL;
28099 }
28100
28101
28102 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28103 PyObject *resultobj = 0;
28104 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28105 wxString *arg2 = 0 ;
28106 void *argp1 = 0 ;
28107 int res1 = 0 ;
28108 bool temp2 = false ;
28109 PyObject * obj0 = 0 ;
28110 PyObject * obj1 = 0 ;
28111 char * kwnames[] = {
28112 (char *) "self",(char *) "text", NULL
28113 };
28114
28115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28119 }
28120 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28121 {
28122 arg2 = wxString_in_helper(obj1);
28123 if (arg2 == NULL) SWIG_fail;
28124 temp2 = true;
28125 }
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 (arg1)->SetText((wxString const &)*arg2);
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 resultobj = SWIG_Py_Void();
28133 {
28134 if (temp2)
28135 delete arg2;
28136 }
28137 return resultobj;
28138 fail:
28139 {
28140 if (temp2)
28141 delete arg2;
28142 }
28143 return NULL;
28144 }
28145
28146
28147 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj = 0;
28149 long arg1 ;
28150 long val1 ;
28151 int ecode1 = 0 ;
28152 PyObject * obj0 = 0 ;
28153 char * kwnames[] = {
28154 (char *) "updateInterval", NULL
28155 };
28156
28157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28158 ecode1 = SWIG_AsVal_long(obj0, &val1);
28159 if (!SWIG_IsOK(ecode1)) {
28160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28161 }
28162 arg1 = static_cast< long >(val1);
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 wxUpdateUIEvent::SetUpdateInterval(arg1);
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_Py_Void();
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28177 PyObject *resultobj = 0;
28178 long result;
28179
28180 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_From_long(static_cast< long >(result));
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 wxWindow *arg1 = (wxWindow *) 0 ;
28197 bool result;
28198 void *argp1 = 0 ;
28199 int res1 = 0 ;
28200 PyObject * obj0 = 0 ;
28201 char * kwnames[] = {
28202 (char *) "win", NULL
28203 };
28204
28205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28207 if (!SWIG_IsOK(res1)) {
28208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28209 }
28210 arg1 = reinterpret_cast< wxWindow * >(argp1);
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28227 PyObject *resultobj = 0;
28228
28229 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 wxUpdateUIEvent::ResetUpdateTime();
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 resultobj = SWIG_Py_Void();
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28244 PyObject *resultobj = 0;
28245 wxUpdateUIMode arg1 ;
28246 int val1 ;
28247 int ecode1 = 0 ;
28248 PyObject * obj0 = 0 ;
28249 char * kwnames[] = {
28250 (char *) "mode", NULL
28251 };
28252
28253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28254 ecode1 = SWIG_AsVal_int(obj0, &val1);
28255 if (!SWIG_IsOK(ecode1)) {
28256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28257 }
28258 arg1 = static_cast< wxUpdateUIMode >(val1);
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 wxUpdateUIEvent::SetMode(arg1);
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 resultobj = SWIG_Py_Void();
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28273 PyObject *resultobj = 0;
28274 wxUpdateUIMode result;
28275
28276 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 resultobj = SWIG_From_int(static_cast< int >(result));
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28291 PyObject *obj;
28292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28293 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28294 return SWIG_Py_Void();
28295 }
28296
28297 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28298 return SWIG_Python_InitShadowInstance(args);
28299 }
28300
28301 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28302 PyObject *resultobj = 0;
28303 wxSysColourChangedEvent *result = 0 ;
28304
28305 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28320 PyObject *obj;
28321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28322 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28323 return SWIG_Py_Void();
28324 }
28325
28326 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28327 return SWIG_Python_InitShadowInstance(args);
28328 }
28329
28330 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj = 0;
28332 int arg1 = (int) 0 ;
28333 wxWindow *arg2 = (wxWindow *) NULL ;
28334 wxMouseCaptureChangedEvent *result = 0 ;
28335 int val1 ;
28336 int ecode1 = 0 ;
28337 void *argp2 = 0 ;
28338 int res2 = 0 ;
28339 PyObject * obj0 = 0 ;
28340 PyObject * obj1 = 0 ;
28341 char * kwnames[] = {
28342 (char *) "winid",(char *) "gainedCapture", NULL
28343 };
28344
28345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28346 if (obj0) {
28347 ecode1 = SWIG_AsVal_int(obj0, &val1);
28348 if (!SWIG_IsOK(ecode1)) {
28349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28350 }
28351 arg1 = static_cast< int >(val1);
28352 }
28353 if (obj1) {
28354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28355 if (!SWIG_IsOK(res2)) {
28356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28357 }
28358 arg2 = reinterpret_cast< wxWindow * >(argp2);
28359 }
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28376 wxWindow *result = 0 ;
28377 void *argp1 = 0 ;
28378 int res1 = 0 ;
28379 PyObject *swig_obj[1] ;
28380
28381 if (!args) SWIG_fail;
28382 swig_obj[0] = args;
28383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28384 if (!SWIG_IsOK(res1)) {
28385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28386 }
28387 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28391 wxPyEndAllowThreads(__tstate);
28392 if (PyErr_Occurred()) SWIG_fail;
28393 }
28394 {
28395 resultobj = wxPyMake_wxObject(result, (bool)0);
28396 }
28397 return resultobj;
28398 fail:
28399 return NULL;
28400 }
28401
28402
28403 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28404 PyObject *obj;
28405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28406 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28407 return SWIG_Py_Void();
28408 }
28409
28410 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 return SWIG_Python_InitShadowInstance(args);
28412 }
28413
28414 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj = 0;
28416 int arg1 = (int) 0 ;
28417 wxMouseCaptureLostEvent *result = 0 ;
28418 int val1 ;
28419 int ecode1 = 0 ;
28420 PyObject * obj0 = 0 ;
28421 char * kwnames[] = {
28422 (char *) "winid", NULL
28423 };
28424
28425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28426 if (obj0) {
28427 ecode1 = SWIG_AsVal_int(obj0, &val1);
28428 if (!SWIG_IsOK(ecode1)) {
28429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28430 }
28431 arg1 = static_cast< int >(val1);
28432 }
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28447 PyObject *obj;
28448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28449 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28450 return SWIG_Py_Void();
28451 }
28452
28453 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28454 return SWIG_Python_InitShadowInstance(args);
28455 }
28456
28457 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28458 PyObject *resultobj = 0;
28459 wxDisplayChangedEvent *result = 0 ;
28460
28461 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28476 PyObject *obj;
28477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28478 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28479 return SWIG_Py_Void();
28480 }
28481
28482 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 return SWIG_Python_InitShadowInstance(args);
28484 }
28485
28486 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj = 0;
28488 int arg1 = (int) 0 ;
28489 wxPaletteChangedEvent *result = 0 ;
28490 int val1 ;
28491 int ecode1 = 0 ;
28492 PyObject * obj0 = 0 ;
28493 char * kwnames[] = {
28494 (char *) "id", NULL
28495 };
28496
28497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28498 if (obj0) {
28499 ecode1 = SWIG_AsVal_int(obj0, &val1);
28500 if (!SWIG_IsOK(ecode1)) {
28501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28502 }
28503 arg1 = static_cast< int >(val1);
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28519 PyObject *resultobj = 0;
28520 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28521 wxWindow *arg2 = (wxWindow *) 0 ;
28522 void *argp1 = 0 ;
28523 int res1 = 0 ;
28524 void *argp2 = 0 ;
28525 int res2 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 PyObject * obj1 = 0 ;
28528 char * kwnames[] = {
28529 (char *) "self",(char *) "win", NULL
28530 };
28531
28532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28534 if (!SWIG_IsOK(res1)) {
28535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28536 }
28537 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28539 if (!SWIG_IsOK(res2)) {
28540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28541 }
28542 arg2 = reinterpret_cast< wxWindow * >(argp2);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 (arg1)->SetChangedWindow(arg2);
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 resultobj = SWIG_Py_Void();
28550 return resultobj;
28551 fail:
28552 return NULL;
28553 }
28554
28555
28556 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28557 PyObject *resultobj = 0;
28558 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28559 wxWindow *result = 0 ;
28560 void *argp1 = 0 ;
28561 int res1 = 0 ;
28562 PyObject *swig_obj[1] ;
28563
28564 if (!args) SWIG_fail;
28565 swig_obj[0] = args;
28566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28569 }
28570 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = (wxWindow *)(arg1)->GetChangedWindow();
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 {
28578 resultobj = wxPyMake_wxObject(result, (bool)0);
28579 }
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *obj;
28588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28589 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28590 return SWIG_Py_Void();
28591 }
28592
28593 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28594 return SWIG_Python_InitShadowInstance(args);
28595 }
28596
28597 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28598 PyObject *resultobj = 0;
28599 int arg1 = (int) 0 ;
28600 wxQueryNewPaletteEvent *result = 0 ;
28601 int val1 ;
28602 int ecode1 = 0 ;
28603 PyObject * obj0 = 0 ;
28604 char * kwnames[] = {
28605 (char *) "winid", NULL
28606 };
28607
28608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28609 if (obj0) {
28610 ecode1 = SWIG_AsVal_int(obj0, &val1);
28611 if (!SWIG_IsOK(ecode1)) {
28612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28613 }
28614 arg1 = static_cast< int >(val1);
28615 }
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28623 return resultobj;
28624 fail:
28625 return NULL;
28626 }
28627
28628
28629 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28630 PyObject *resultobj = 0;
28631 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28632 bool arg2 ;
28633 void *argp1 = 0 ;
28634 int res1 = 0 ;
28635 bool val2 ;
28636 int ecode2 = 0 ;
28637 PyObject * obj0 = 0 ;
28638 PyObject * obj1 = 0 ;
28639 char * kwnames[] = {
28640 (char *) "self",(char *) "realized", NULL
28641 };
28642
28643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28645 if (!SWIG_IsOK(res1)) {
28646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28647 }
28648 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28650 if (!SWIG_IsOK(ecode2)) {
28651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28652 }
28653 arg2 = static_cast< bool >(val2);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 (arg1)->SetPaletteRealized(arg2);
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_Py_Void();
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28670 bool result;
28671 void *argp1 = 0 ;
28672 int res1 = 0 ;
28673 PyObject *swig_obj[1] ;
28674
28675 if (!args) SWIG_fail;
28676 swig_obj[0] = args;
28677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28680 }
28681 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 {
28689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28690 }
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28698 PyObject *obj;
28699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28700 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28701 return SWIG_Py_Void();
28702 }
28703
28704 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28705 return SWIG_Python_InitShadowInstance(args);
28706 }
28707
28708 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28709 PyObject *resultobj = 0;
28710 wxNavigationKeyEvent *result = 0 ;
28711
28712 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28716 wxPyEndAllowThreads(__tstate);
28717 if (PyErr_Occurred()) SWIG_fail;
28718 }
28719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28727 PyObject *resultobj = 0;
28728 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28729 bool result;
28730 void *argp1 = 0 ;
28731 int res1 = 0 ;
28732 PyObject *swig_obj[1] ;
28733
28734 if (!args) SWIG_fail;
28735 swig_obj[0] = args;
28736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28737 if (!SWIG_IsOK(res1)) {
28738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28739 }
28740 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 {
28748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28749 }
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28757 PyObject *resultobj = 0;
28758 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28759 bool arg2 ;
28760 void *argp1 = 0 ;
28761 int res1 = 0 ;
28762 bool val2 ;
28763 int ecode2 = 0 ;
28764 PyObject * obj0 = 0 ;
28765 PyObject * obj1 = 0 ;
28766 char * kwnames[] = {
28767 (char *) "self",(char *) "forward", NULL
28768 };
28769
28770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28772 if (!SWIG_IsOK(res1)) {
28773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28774 }
28775 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28776 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28777 if (!SWIG_IsOK(ecode2)) {
28778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28779 }
28780 arg2 = static_cast< bool >(val2);
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 (arg1)->SetDirection(arg2);
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_Py_Void();
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28795 PyObject *resultobj = 0;
28796 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28797 bool result;
28798 void *argp1 = 0 ;
28799 int res1 = 0 ;
28800 PyObject *swig_obj[1] ;
28801
28802 if (!args) SWIG_fail;
28803 swig_obj[0] = args;
28804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28805 if (!SWIG_IsOK(res1)) {
28806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28807 }
28808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 {
28816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28817 }
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj = 0;
28826 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28827 bool arg2 ;
28828 void *argp1 = 0 ;
28829 int res1 = 0 ;
28830 bool val2 ;
28831 int ecode2 = 0 ;
28832 PyObject * obj0 = 0 ;
28833 PyObject * obj1 = 0 ;
28834 char * kwnames[] = {
28835 (char *) "self",(char *) "ischange", NULL
28836 };
28837
28838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28840 if (!SWIG_IsOK(res1)) {
28841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28842 }
28843 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28845 if (!SWIG_IsOK(ecode2)) {
28846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28847 }
28848 arg2 = static_cast< bool >(val2);
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 (arg1)->SetWindowChange(arg2);
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_Py_Void();
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 PyObject *resultobj = 0;
28864 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28865 bool result;
28866 void *argp1 = 0 ;
28867 int res1 = 0 ;
28868 PyObject *swig_obj[1] ;
28869
28870 if (!args) SWIG_fail;
28871 swig_obj[0] = args;
28872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28875 }
28876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 {
28884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28885 }
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28893 PyObject *resultobj = 0;
28894 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28895 bool arg2 ;
28896 void *argp1 = 0 ;
28897 int res1 = 0 ;
28898 bool val2 ;
28899 int ecode2 = 0 ;
28900 PyObject * obj0 = 0 ;
28901 PyObject * obj1 = 0 ;
28902 char * kwnames[] = {
28903 (char *) "self",(char *) "bIs", NULL
28904 };
28905
28906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28908 if (!SWIG_IsOK(res1)) {
28909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28910 }
28911 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28913 if (!SWIG_IsOK(ecode2)) {
28914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28915 }
28916 arg2 = static_cast< bool >(val2);
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 (arg1)->SetFromTab(arg2);
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_Py_Void();
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28931 PyObject *resultobj = 0;
28932 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28933 long arg2 ;
28934 void *argp1 = 0 ;
28935 int res1 = 0 ;
28936 long val2 ;
28937 int ecode2 = 0 ;
28938 PyObject * obj0 = 0 ;
28939 PyObject * obj1 = 0 ;
28940 char * kwnames[] = {
28941 (char *) "self",(char *) "flags", NULL
28942 };
28943
28944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28946 if (!SWIG_IsOK(res1)) {
28947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28948 }
28949 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28950 ecode2 = SWIG_AsVal_long(obj1, &val2);
28951 if (!SWIG_IsOK(ecode2)) {
28952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28953 }
28954 arg2 = static_cast< long >(val2);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 (arg1)->SetFlags(arg2);
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_Py_Void();
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28969 PyObject *resultobj = 0;
28970 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28971 wxWindow *result = 0 ;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 PyObject *swig_obj[1] ;
28975
28976 if (!args) SWIG_fail;
28977 swig_obj[0] = args;
28978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28981 }
28982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 {
28990 resultobj = wxPyMake_wxObject(result, (bool)0);
28991 }
28992 return resultobj;
28993 fail:
28994 return NULL;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28999 PyObject *resultobj = 0;
29000 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29001 wxWindow *arg2 = (wxWindow *) 0 ;
29002 void *argp1 = 0 ;
29003 int res1 = 0 ;
29004 void *argp2 = 0 ;
29005 int res2 = 0 ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 char * kwnames[] = {
29009 (char *) "self",(char *) "win", NULL
29010 };
29011
29012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29014 if (!SWIG_IsOK(res1)) {
29015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29016 }
29017 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29019 if (!SWIG_IsOK(res2)) {
29020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29021 }
29022 arg2 = reinterpret_cast< wxWindow * >(argp2);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 (arg1)->SetCurrentFocus(arg2);
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 resultobj = SWIG_Py_Void();
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29037 PyObject *obj;
29038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29039 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29040 return SWIG_Py_Void();
29041 }
29042
29043 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 return SWIG_Python_InitShadowInstance(args);
29045 }
29046
29047 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29048 PyObject *resultobj = 0;
29049 wxWindow *arg1 = (wxWindow *) NULL ;
29050 wxWindowCreateEvent *result = 0 ;
29051 void *argp1 = 0 ;
29052 int res1 = 0 ;
29053 PyObject * obj0 = 0 ;
29054 char * kwnames[] = {
29055 (char *) "win", NULL
29056 };
29057
29058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29059 if (obj0) {
29060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29061 if (!SWIG_IsOK(res1)) {
29062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29063 }
29064 arg1 = reinterpret_cast< wxWindow * >(argp1);
29065 }
29066 {
29067 PyThreadState* __tstate = wxPyBeginAllowThreads();
29068 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29080 PyObject *resultobj = 0;
29081 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29082 wxWindow *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject *swig_obj[1] ;
29086
29087 if (!args) SWIG_fail;
29088 swig_obj[0] = args;
29089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29090 if (!SWIG_IsOK(res1)) {
29091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29092 }
29093 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 {
29101 resultobj = wxPyMake_wxObject(result, (bool)0);
29102 }
29103 return resultobj;
29104 fail:
29105 return NULL;
29106 }
29107
29108
29109 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29110 PyObject *obj;
29111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29112 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29113 return SWIG_Py_Void();
29114 }
29115
29116 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 return SWIG_Python_InitShadowInstance(args);
29118 }
29119
29120 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj = 0;
29122 wxWindow *arg1 = (wxWindow *) NULL ;
29123 wxWindowDestroyEvent *result = 0 ;
29124 void *argp1 = 0 ;
29125 int res1 = 0 ;
29126 PyObject * obj0 = 0 ;
29127 char * kwnames[] = {
29128 (char *) "win", NULL
29129 };
29130
29131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29132 if (obj0) {
29133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29134 if (!SWIG_IsOK(res1)) {
29135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29136 }
29137 arg1 = reinterpret_cast< wxWindow * >(argp1);
29138 }
29139 {
29140 PyThreadState* __tstate = wxPyBeginAllowThreads();
29141 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29153 PyObject *resultobj = 0;
29154 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29155 wxWindow *result = 0 ;
29156 void *argp1 = 0 ;
29157 int res1 = 0 ;
29158 PyObject *swig_obj[1] ;
29159
29160 if (!args) SWIG_fail;
29161 swig_obj[0] = args;
29162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29163 if (!SWIG_IsOK(res1)) {
29164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29165 }
29166 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 {
29174 resultobj = wxPyMake_wxObject(result, (bool)0);
29175 }
29176 return resultobj;
29177 fail:
29178 return NULL;
29179 }
29180
29181
29182 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29183 PyObject *obj;
29184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29185 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29186 return SWIG_Py_Void();
29187 }
29188
29189 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29190 return SWIG_Python_InitShadowInstance(args);
29191 }
29192
29193 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj = 0;
29195 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29196 int arg2 = (int) 0 ;
29197 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29198 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29199 wxContextMenuEvent *result = 0 ;
29200 int val1 ;
29201 int ecode1 = 0 ;
29202 int val2 ;
29203 int ecode2 = 0 ;
29204 wxPoint temp3 ;
29205 PyObject * obj0 = 0 ;
29206 PyObject * obj1 = 0 ;
29207 PyObject * obj2 = 0 ;
29208 char * kwnames[] = {
29209 (char *) "type",(char *) "winid",(char *) "pt", NULL
29210 };
29211
29212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29213 if (obj0) {
29214 ecode1 = SWIG_AsVal_int(obj0, &val1);
29215 if (!SWIG_IsOK(ecode1)) {
29216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29217 }
29218 arg1 = static_cast< wxEventType >(val1);
29219 }
29220 if (obj1) {
29221 ecode2 = SWIG_AsVal_int(obj1, &val2);
29222 if (!SWIG_IsOK(ecode2)) {
29223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29224 }
29225 arg2 = static_cast< int >(val2);
29226 }
29227 if (obj2) {
29228 {
29229 arg3 = &temp3;
29230 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29231 }
29232 }
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *resultobj = 0;
29248 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29249 wxPoint *result = 0 ;
29250 void *argp1 = 0 ;
29251 int res1 = 0 ;
29252 PyObject *swig_obj[1] ;
29253
29254 if (!args) SWIG_fail;
29255 swig_obj[0] = args;
29256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29257 if (!SWIG_IsOK(res1)) {
29258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29259 }
29260 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 {
29264 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29265 result = (wxPoint *) &_result_ref;
29266 }
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj = 0;
29279 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29280 wxPoint *arg2 = 0 ;
29281 void *argp1 = 0 ;
29282 int res1 = 0 ;
29283 wxPoint temp2 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "pos", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29294 }
29295 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29296 {
29297 arg2 = &temp2;
29298 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29299 }
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 (arg1)->SetPosition((wxPoint const &)*arg2);
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_Py_Void();
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29314 PyObject *obj;
29315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29316 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29317 return SWIG_Py_Void();
29318 }
29319
29320 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29321 return SWIG_Python_InitShadowInstance(args);
29322 }
29323
29324 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325 PyObject *resultobj = 0;
29326 wxIdleEvent *result = 0 ;
29327
29328 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29329 {
29330 PyThreadState* __tstate = wxPyBeginAllowThreads();
29331 result = (wxIdleEvent *)new wxIdleEvent();
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29336 return resultobj;
29337 fail:
29338 return NULL;
29339 }
29340
29341
29342 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29343 PyObject *resultobj = 0;
29344 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29345 bool arg2 = (bool) true ;
29346 void *argp1 = 0 ;
29347 int res1 = 0 ;
29348 bool val2 ;
29349 int ecode2 = 0 ;
29350 PyObject * obj0 = 0 ;
29351 PyObject * obj1 = 0 ;
29352 char * kwnames[] = {
29353 (char *) "self",(char *) "needMore", NULL
29354 };
29355
29356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29358 if (!SWIG_IsOK(res1)) {
29359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29360 }
29361 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29362 if (obj1) {
29363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29364 if (!SWIG_IsOK(ecode2)) {
29365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29366 }
29367 arg2 = static_cast< bool >(val2);
29368 }
29369 {
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 (arg1)->RequestMore(arg2);
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 resultobj = SWIG_Py_Void();
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29385 bool result;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 PyObject *swig_obj[1] ;
29389
29390 if (!args) SWIG_fail;
29391 swig_obj[0] = args;
29392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29393 if (!SWIG_IsOK(res1)) {
29394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29395 }
29396 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 {
29404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29405 }
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj = 0;
29414 wxIdleMode arg1 ;
29415 int val1 ;
29416 int ecode1 = 0 ;
29417 PyObject * obj0 = 0 ;
29418 char * kwnames[] = {
29419 (char *) "mode", NULL
29420 };
29421
29422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29423 ecode1 = SWIG_AsVal_int(obj0, &val1);
29424 if (!SWIG_IsOK(ecode1)) {
29425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29426 }
29427 arg1 = static_cast< wxIdleMode >(val1);
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 wxIdleEvent::SetMode(arg1);
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 resultobj = SWIG_Py_Void();
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29442 PyObject *resultobj = 0;
29443 wxIdleMode result;
29444
29445 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (wxIdleMode)wxIdleEvent::GetMode();
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_From_int(static_cast< int >(result));
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = 0;
29461 wxWindow *arg1 = (wxWindow *) 0 ;
29462 bool result;
29463 void *argp1 = 0 ;
29464 int res1 = 0 ;
29465 PyObject * obj0 = 0 ;
29466 char * kwnames[] = {
29467 (char *) "win", NULL
29468 };
29469
29470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29472 if (!SWIG_IsOK(res1)) {
29473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29474 }
29475 arg1 = reinterpret_cast< wxWindow * >(argp1);
29476 {
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (bool)wxIdleEvent::CanSend(arg1);
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 {
29483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29484 }
29485 return resultobj;
29486 fail:
29487 return NULL;
29488 }
29489
29490
29491 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29492 PyObject *obj;
29493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29494 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29495 return SWIG_Py_Void();
29496 }
29497
29498 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29499 return SWIG_Python_InitShadowInstance(args);
29500 }
29501
29502 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj = 0;
29504 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29505 int arg2 = (int) 0 ;
29506 wxClipboardTextEvent *result = 0 ;
29507 int val1 ;
29508 int ecode1 = 0 ;
29509 int val2 ;
29510 int ecode2 = 0 ;
29511 PyObject * obj0 = 0 ;
29512 PyObject * obj1 = 0 ;
29513 char * kwnames[] = {
29514 (char *) "type",(char *) "winid", NULL
29515 };
29516
29517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29518 if (obj0) {
29519 ecode1 = SWIG_AsVal_int(obj0, &val1);
29520 if (!SWIG_IsOK(ecode1)) {
29521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29522 }
29523 arg1 = static_cast< wxEventType >(val1);
29524 }
29525 if (obj1) {
29526 ecode2 = SWIG_AsVal_int(obj1, &val2);
29527 if (!SWIG_IsOK(ecode2)) {
29528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29529 }
29530 arg2 = static_cast< int >(val2);
29531 }
29532 {
29533 PyThreadState* __tstate = wxPyBeginAllowThreads();
29534 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29546 PyObject *obj;
29547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29548 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29549 return SWIG_Py_Void();
29550 }
29551
29552 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29553 return SWIG_Python_InitShadowInstance(args);
29554 }
29555
29556 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj = 0;
29558 int arg1 = (int) 0 ;
29559 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29560 wxPyEvent *result = 0 ;
29561 int val1 ;
29562 int ecode1 = 0 ;
29563 int val2 ;
29564 int ecode2 = 0 ;
29565 PyObject * obj0 = 0 ;
29566 PyObject * obj1 = 0 ;
29567 char * kwnames[] = {
29568 (char *) "winid",(char *) "eventType", NULL
29569 };
29570
29571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29572 if (obj0) {
29573 ecode1 = SWIG_AsVal_int(obj0, &val1);
29574 if (!SWIG_IsOK(ecode1)) {
29575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29576 }
29577 arg1 = static_cast< int >(val1);
29578 }
29579 if (obj1) {
29580 ecode2 = SWIG_AsVal_int(obj1, &val2);
29581 if (!SWIG_IsOK(ecode2)) {
29582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29583 }
29584 arg2 = static_cast< wxEventType >(val2);
29585 }
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29602 void *argp1 = 0 ;
29603 int res1 = 0 ;
29604 PyObject *swig_obj[1] ;
29605
29606 if (!args) SWIG_fail;
29607 swig_obj[0] = args;
29608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29609 if (!SWIG_IsOK(res1)) {
29610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29611 }
29612 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 delete arg1;
29616
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 resultobj = SWIG_Py_Void();
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj = 0;
29629 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29630 PyObject *arg2 = (PyObject *) 0 ;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject * obj0 = 0 ;
29634 PyObject * obj1 = 0 ;
29635 char * kwnames[] = {
29636 (char *) "self",(char *) "self", NULL
29637 };
29638
29639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29641 if (!SWIG_IsOK(res1)) {
29642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29643 }
29644 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29645 arg2 = obj1;
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 (arg1)->SetSelf(arg2);
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_Py_Void();
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29660 PyObject *resultobj = 0;
29661 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29662 PyObject *result = 0 ;
29663 void *argp1 = 0 ;
29664 int res1 = 0 ;
29665 PyObject *swig_obj[1] ;
29666
29667 if (!args) SWIG_fail;
29668 swig_obj[0] = args;
29669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29670 if (!SWIG_IsOK(res1)) {
29671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29672 }
29673 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29674 {
29675 PyThreadState* __tstate = wxPyBeginAllowThreads();
29676 result = (PyObject *)(arg1)->GetSelf();
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = result;
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29688 PyObject *obj;
29689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29690 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29691 return SWIG_Py_Void();
29692 }
29693
29694 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29695 return SWIG_Python_InitShadowInstance(args);
29696 }
29697
29698 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj = 0;
29700 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29701 int arg2 = (int) 0 ;
29702 wxPyCommandEvent *result = 0 ;
29703 int val1 ;
29704 int ecode1 = 0 ;
29705 int val2 ;
29706 int ecode2 = 0 ;
29707 PyObject * obj0 = 0 ;
29708 PyObject * obj1 = 0 ;
29709 char * kwnames[] = {
29710 (char *) "eventType",(char *) "id", NULL
29711 };
29712
29713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29714 if (obj0) {
29715 ecode1 = SWIG_AsVal_int(obj0, &val1);
29716 if (!SWIG_IsOK(ecode1)) {
29717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29718 }
29719 arg1 = static_cast< wxEventType >(val1);
29720 }
29721 if (obj1) {
29722 ecode2 = SWIG_AsVal_int(obj1, &val2);
29723 if (!SWIG_IsOK(ecode2)) {
29724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29725 }
29726 arg2 = static_cast< int >(val2);
29727 }
29728 {
29729 PyThreadState* __tstate = wxPyBeginAllowThreads();
29730 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29731 wxPyEndAllowThreads(__tstate);
29732 if (PyErr_Occurred()) SWIG_fail;
29733 }
29734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29735 return resultobj;
29736 fail:
29737 return NULL;
29738 }
29739
29740
29741 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29742 PyObject *resultobj = 0;
29743 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29744 void *argp1 = 0 ;
29745 int res1 = 0 ;
29746 PyObject *swig_obj[1] ;
29747
29748 if (!args) SWIG_fail;
29749 swig_obj[0] = args;
29750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29751 if (!SWIG_IsOK(res1)) {
29752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29753 }
29754 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 delete arg1;
29758
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 resultobj = SWIG_Py_Void();
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj = 0;
29771 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29772 PyObject *arg2 = (PyObject *) 0 ;
29773 void *argp1 = 0 ;
29774 int res1 = 0 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 char * kwnames[] = {
29778 (char *) "self",(char *) "self", NULL
29779 };
29780
29781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29783 if (!SWIG_IsOK(res1)) {
29784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29785 }
29786 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29787 arg2 = obj1;
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 (arg1)->SetSelf(arg2);
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_Py_Void();
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29802 PyObject *resultobj = 0;
29803 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29804 PyObject *result = 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject *swig_obj[1] ;
29808
29809 if (!args) SWIG_fail;
29810 swig_obj[0] = args;
29811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29812 if (!SWIG_IsOK(res1)) {
29813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29814 }
29815 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (PyObject *)(arg1)->GetSelf();
29819 wxPyEndAllowThreads(__tstate);
29820 if (PyErr_Occurred()) SWIG_fail;
29821 }
29822 resultobj = result;
29823 return resultobj;
29824 fail:
29825 return NULL;
29826 }
29827
29828
29829 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29830 PyObject *obj;
29831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29832 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29833 return SWIG_Py_Void();
29834 }
29835
29836 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29837 return SWIG_Python_InitShadowInstance(args);
29838 }
29839
29840 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj = 0;
29842 wxWindow *arg1 = (wxWindow *) 0 ;
29843 wxDateTime *arg2 = 0 ;
29844 wxEventType arg3 ;
29845 wxDateEvent *result = 0 ;
29846 void *argp1 = 0 ;
29847 int res1 = 0 ;
29848 void *argp2 = 0 ;
29849 int res2 = 0 ;
29850 int val3 ;
29851 int ecode3 = 0 ;
29852 PyObject * obj0 = 0 ;
29853 PyObject * obj1 = 0 ;
29854 PyObject * obj2 = 0 ;
29855 char * kwnames[] = {
29856 (char *) "win",(char *) "dt",(char *) "type", NULL
29857 };
29858
29859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29863 }
29864 arg1 = reinterpret_cast< wxWindow * >(argp1);
29865 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29866 if (!SWIG_IsOK(res2)) {
29867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29868 }
29869 if (!argp2) {
29870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29871 }
29872 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29873 ecode3 = SWIG_AsVal_int(obj2, &val3);
29874 if (!SWIG_IsOK(ecode3)) {
29875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29876 }
29877 arg3 = static_cast< wxEventType >(val3);
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29894 wxDateTime *result = 0 ;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 PyObject *swig_obj[1] ;
29898
29899 if (!args) SWIG_fail;
29900 swig_obj[0] = args;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 {
29909 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29910 result = (wxDateTime *) &_result_ref;
29911 }
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29923 PyObject *resultobj = 0;
29924 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29925 wxDateTime *arg2 = 0 ;
29926 void *argp1 = 0 ;
29927 int res1 = 0 ;
29928 void *argp2 = 0 ;
29929 int res2 = 0 ;
29930 PyObject * obj0 = 0 ;
29931 PyObject * obj1 = 0 ;
29932 char * kwnames[] = {
29933 (char *) "self",(char *) "date", NULL
29934 };
29935
29936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29938 if (!SWIG_IsOK(res1)) {
29939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29940 }
29941 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29943 if (!SWIG_IsOK(res2)) {
29944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29945 }
29946 if (!argp2) {
29947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29948 }
29949 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 (arg1)->SetDate((wxDateTime const &)*arg2);
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 resultobj = SWIG_Py_Void();
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29964 PyObject *obj;
29965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29966 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29967 return SWIG_Py_Void();
29968 }
29969
29970 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29971 return SWIG_Python_InitShadowInstance(args);
29972 }
29973
29974 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29975 PyObject *resultobj = 0;
29976 wxPyApp *result = 0 ;
29977
29978 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29979 {
29980 PyThreadState* __tstate = wxPyBeginAllowThreads();
29981 result = (wxPyApp *)new_wxPyApp();
29982 wxPyEndAllowThreads(__tstate);
29983 if (PyErr_Occurred()) SWIG_fail;
29984 }
29985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29986 return resultobj;
29987 fail:
29988 return NULL;
29989 }
29990
29991
29992 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29993 PyObject *resultobj = 0;
29994 wxPyApp *arg1 = (wxPyApp *) 0 ;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 PyObject *swig_obj[1] ;
29998
29999 if (!args) SWIG_fail;
30000 swig_obj[0] = args;
30001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30002 if (!SWIG_IsOK(res1)) {
30003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30004 }
30005 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30006 {
30007 PyThreadState* __tstate = wxPyBeginAllowThreads();
30008 delete arg1;
30009
30010 wxPyEndAllowThreads(__tstate);
30011 if (PyErr_Occurred()) SWIG_fail;
30012 }
30013 resultobj = SWIG_Py_Void();
30014 return resultobj;
30015 fail:
30016 return NULL;
30017 }
30018
30019
30020 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30021 PyObject *resultobj = 0;
30022 wxPyApp *arg1 = (wxPyApp *) 0 ;
30023 PyObject *arg2 = (PyObject *) 0 ;
30024 PyObject *arg3 = (PyObject *) 0 ;
30025 bool arg4 ;
30026 void *argp1 = 0 ;
30027 int res1 = 0 ;
30028 bool val4 ;
30029 int ecode4 = 0 ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 PyObject * obj2 = 0 ;
30033 PyObject * obj3 = 0 ;
30034 char * kwnames[] = {
30035 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30036 };
30037
30038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30042 }
30043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30044 arg2 = obj1;
30045 arg3 = obj2;
30046 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30047 if (!SWIG_IsOK(ecode4)) {
30048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30049 }
30050 arg4 = static_cast< bool >(val4);
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 resultobj = SWIG_Py_Void();
30058 return resultobj;
30059 fail:
30060 return NULL;
30061 }
30062
30063
30064 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30065 PyObject *resultobj = 0;
30066 wxPyApp *arg1 = (wxPyApp *) 0 ;
30067 wxString result;
30068 void *argp1 = 0 ;
30069 int res1 = 0 ;
30070 PyObject *swig_obj[1] ;
30071
30072 if (!args) SWIG_fail;
30073 swig_obj[0] = args;
30074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30075 if (!SWIG_IsOK(res1)) {
30076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30077 }
30078 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = ((wxPyApp const *)arg1)->GetAppName();
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 {
30086 #if wxUSE_UNICODE
30087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30088 #else
30089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30090 #endif
30091 }
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = 0;
30100 wxPyApp *arg1 = (wxPyApp *) 0 ;
30101 wxString *arg2 = 0 ;
30102 void *argp1 = 0 ;
30103 int res1 = 0 ;
30104 bool temp2 = false ;
30105 PyObject * obj0 = 0 ;
30106 PyObject * obj1 = 0 ;
30107 char * kwnames[] = {
30108 (char *) "self",(char *) "name", NULL
30109 };
30110
30111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30113 if (!SWIG_IsOK(res1)) {
30114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30115 }
30116 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30117 {
30118 arg2 = wxString_in_helper(obj1);
30119 if (arg2 == NULL) SWIG_fail;
30120 temp2 = true;
30121 }
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 (arg1)->SetAppName((wxString const &)*arg2);
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_Py_Void();
30129 {
30130 if (temp2)
30131 delete arg2;
30132 }
30133 return resultobj;
30134 fail:
30135 {
30136 if (temp2)
30137 delete arg2;
30138 }
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 wxPyApp *arg1 = (wxPyApp *) 0 ;
30146 wxString result;
30147 void *argp1 = 0 ;
30148 int res1 = 0 ;
30149 PyObject *swig_obj[1] ;
30150
30151 if (!args) SWIG_fail;
30152 swig_obj[0] = args;
30153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30154 if (!SWIG_IsOK(res1)) {
30155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30156 }
30157 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 result = ((wxPyApp const *)arg1)->GetClassName();
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 {
30165 #if wxUSE_UNICODE
30166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30167 #else
30168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30169 #endif
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 wxPyApp *arg1 = (wxPyApp *) 0 ;
30180 wxString *arg2 = 0 ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 bool temp2 = false ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "self",(char *) "name", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30192 if (!SWIG_IsOK(res1)) {
30193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30194 }
30195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30196 {
30197 arg2 = wxString_in_helper(obj1);
30198 if (arg2 == NULL) SWIG_fail;
30199 temp2 = true;
30200 }
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 (arg1)->SetClassName((wxString const &)*arg2);
30204 wxPyEndAllowThreads(__tstate);
30205 if (PyErr_Occurred()) SWIG_fail;
30206 }
30207 resultobj = SWIG_Py_Void();
30208 {
30209 if (temp2)
30210 delete arg2;
30211 }
30212 return resultobj;
30213 fail:
30214 {
30215 if (temp2)
30216 delete arg2;
30217 }
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxPyApp *arg1 = (wxPyApp *) 0 ;
30225 wxString *result = 0 ;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 PyObject *swig_obj[1] ;
30229
30230 if (!args) SWIG_fail;
30231 swig_obj[0] = args;
30232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30235 }
30236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 {
30240 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30241 result = (wxString *) &_result_ref;
30242 }
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 {
30247 #if wxUSE_UNICODE
30248 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30249 #else
30250 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30251 #endif
30252 }
30253 return resultobj;
30254 fail:
30255 return NULL;
30256 }
30257
30258
30259 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30260 PyObject *resultobj = 0;
30261 wxPyApp *arg1 = (wxPyApp *) 0 ;
30262 wxString *arg2 = 0 ;
30263 void *argp1 = 0 ;
30264 int res1 = 0 ;
30265 bool temp2 = false ;
30266 PyObject * obj0 = 0 ;
30267 PyObject * obj1 = 0 ;
30268 char * kwnames[] = {
30269 (char *) "self",(char *) "name", NULL
30270 };
30271
30272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30274 if (!SWIG_IsOK(res1)) {
30275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30276 }
30277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30278 {
30279 arg2 = wxString_in_helper(obj1);
30280 if (arg2 == NULL) SWIG_fail;
30281 temp2 = true;
30282 }
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 (arg1)->SetVendorName((wxString const &)*arg2);
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 resultobj = SWIG_Py_Void();
30290 {
30291 if (temp2)
30292 delete arg2;
30293 }
30294 return resultobj;
30295 fail:
30296 {
30297 if (temp2)
30298 delete arg2;
30299 }
30300 return NULL;
30301 }
30302
30303
30304 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30305 PyObject *resultobj = 0;
30306 wxPyApp *arg1 = (wxPyApp *) 0 ;
30307 wxAppTraits *result = 0 ;
30308 void *argp1 = 0 ;
30309 int res1 = 0 ;
30310 PyObject *swig_obj[1] ;
30311
30312 if (!args) SWIG_fail;
30313 swig_obj[0] = args;
30314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30315 if (!SWIG_IsOK(res1)) {
30316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30317 }
30318 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 result = (wxAppTraits *)(arg1)->GetTraits();
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30326 return resultobj;
30327 fail:
30328 return NULL;
30329 }
30330
30331
30332 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30333 PyObject *resultobj = 0;
30334 wxPyApp *arg1 = (wxPyApp *) 0 ;
30335 void *argp1 = 0 ;
30336 int res1 = 0 ;
30337 PyObject *swig_obj[1] ;
30338
30339 if (!args) SWIG_fail;
30340 swig_obj[0] = args;
30341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30342 if (!SWIG_IsOK(res1)) {
30343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30344 }
30345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30346 {
30347 PyThreadState* __tstate = wxPyBeginAllowThreads();
30348 (arg1)->ProcessPendingEvents();
30349 wxPyEndAllowThreads(__tstate);
30350 if (PyErr_Occurred()) SWIG_fail;
30351 }
30352 resultobj = SWIG_Py_Void();
30353 return resultobj;
30354 fail:
30355 return NULL;
30356 }
30357
30358
30359 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30360 PyObject *resultobj = 0;
30361 wxPyApp *arg1 = (wxPyApp *) 0 ;
30362 bool arg2 = (bool) false ;
30363 bool result;
30364 void *argp1 = 0 ;
30365 int res1 = 0 ;
30366 bool val2 ;
30367 int ecode2 = 0 ;
30368 PyObject * obj0 = 0 ;
30369 PyObject * obj1 = 0 ;
30370 char * kwnames[] = {
30371 (char *) "self",(char *) "onlyIfNeeded", NULL
30372 };
30373
30374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30376 if (!SWIG_IsOK(res1)) {
30377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30378 }
30379 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30380 if (obj1) {
30381 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30382 if (!SWIG_IsOK(ecode2)) {
30383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30384 }
30385 arg2 = static_cast< bool >(val2);
30386 }
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (bool)(arg1)->Yield(arg2);
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 {
30394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30403 PyObject *resultobj = 0;
30404 wxPyApp *arg1 = (wxPyApp *) 0 ;
30405 void *argp1 = 0 ;
30406 int res1 = 0 ;
30407 PyObject *swig_obj[1] ;
30408
30409 if (!args) SWIG_fail;
30410 swig_obj[0] = args;
30411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30414 }
30415 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->WakeUpIdle();
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30430 PyObject *resultobj = 0;
30431 bool result;
30432
30433 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30434 {
30435 PyThreadState* __tstate = wxPyBeginAllowThreads();
30436 result = (bool)wxPyApp::IsMainLoopRunning();
30437 wxPyEndAllowThreads(__tstate);
30438 if (PyErr_Occurred()) SWIG_fail;
30439 }
30440 {
30441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30442 }
30443 return resultobj;
30444 fail:
30445 return NULL;
30446 }
30447
30448
30449 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30450 PyObject *resultobj = 0;
30451 wxPyApp *arg1 = (wxPyApp *) 0 ;
30452 int result;
30453 void *argp1 = 0 ;
30454 int res1 = 0 ;
30455 PyObject *swig_obj[1] ;
30456
30457 if (!args) SWIG_fail;
30458 swig_obj[0] = args;
30459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30462 }
30463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 result = (int)(arg1)->MainLoop();
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 resultobj = SWIG_From_int(static_cast< int >(result));
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxPyApp *arg1 = (wxPyApp *) 0 ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 PyObject *swig_obj[1] ;
30483
30484 if (!args) SWIG_fail;
30485 swig_obj[0] = args;
30486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30487 if (!SWIG_IsOK(res1)) {
30488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30489 }
30490 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30491 {
30492 PyThreadState* __tstate = wxPyBeginAllowThreads();
30493 (arg1)->Exit();
30494 wxPyEndAllowThreads(__tstate);
30495 if (PyErr_Occurred()) SWIG_fail;
30496 }
30497 resultobj = SWIG_Py_Void();
30498 return resultobj;
30499 fail:
30500 return NULL;
30501 }
30502
30503
30504 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30505 PyObject *resultobj = 0;
30506 wxPyApp *arg1 = (wxPyApp *) 0 ;
30507 wxLayoutDirection result;
30508 void *argp1 = 0 ;
30509 int res1 = 0 ;
30510 PyObject *swig_obj[1] ;
30511
30512 if (!args) SWIG_fail;
30513 swig_obj[0] = args;
30514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30515 if (!SWIG_IsOK(res1)) {
30516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30517 }
30518 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_From_int(static_cast< int >(result));
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30533 PyObject *resultobj = 0;
30534 wxPyApp *arg1 = (wxPyApp *) 0 ;
30535 void *argp1 = 0 ;
30536 int res1 = 0 ;
30537 PyObject *swig_obj[1] ;
30538
30539 if (!args) SWIG_fail;
30540 swig_obj[0] = args;
30541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30542 if (!SWIG_IsOK(res1)) {
30543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30544 }
30545 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30546 {
30547 PyThreadState* __tstate = wxPyBeginAllowThreads();
30548 (arg1)->ExitMainLoop();
30549 wxPyEndAllowThreads(__tstate);
30550 if (PyErr_Occurred()) SWIG_fail;
30551 }
30552 resultobj = SWIG_Py_Void();
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30560 PyObject *resultobj = 0;
30561 wxPyApp *arg1 = (wxPyApp *) 0 ;
30562 bool result;
30563 void *argp1 = 0 ;
30564 int res1 = 0 ;
30565 PyObject *swig_obj[1] ;
30566
30567 if (!args) SWIG_fail;
30568 swig_obj[0] = args;
30569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30570 if (!SWIG_IsOK(res1)) {
30571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30572 }
30573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 result = (bool)(arg1)->Pending();
30577 wxPyEndAllowThreads(__tstate);
30578 if (PyErr_Occurred()) SWIG_fail;
30579 }
30580 {
30581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30582 }
30583 return resultobj;
30584 fail:
30585 return NULL;
30586 }
30587
30588
30589 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30590 PyObject *resultobj = 0;
30591 wxPyApp *arg1 = (wxPyApp *) 0 ;
30592 bool result;
30593 void *argp1 = 0 ;
30594 int res1 = 0 ;
30595 PyObject *swig_obj[1] ;
30596
30597 if (!args) SWIG_fail;
30598 swig_obj[0] = args;
30599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30600 if (!SWIG_IsOK(res1)) {
30601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30602 }
30603 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 result = (bool)(arg1)->Dispatch();
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 {
30611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30612 }
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30620 PyObject *resultobj = 0;
30621 wxPyApp *arg1 = (wxPyApp *) 0 ;
30622 bool result;
30623 void *argp1 = 0 ;
30624 int res1 = 0 ;
30625 PyObject *swig_obj[1] ;
30626
30627 if (!args) SWIG_fail;
30628 swig_obj[0] = args;
30629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30630 if (!SWIG_IsOK(res1)) {
30631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30632 }
30633 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30634 {
30635 PyThreadState* __tstate = wxPyBeginAllowThreads();
30636 result = (bool)(arg1)->ProcessIdle();
30637 wxPyEndAllowThreads(__tstate);
30638 if (PyErr_Occurred()) SWIG_fail;
30639 }
30640 {
30641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30642 }
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj = 0;
30651 wxPyApp *arg1 = (wxPyApp *) 0 ;
30652 wxWindow *arg2 = (wxWindow *) 0 ;
30653 wxIdleEvent *arg3 = 0 ;
30654 bool result;
30655 void *argp1 = 0 ;
30656 int res1 = 0 ;
30657 void *argp2 = 0 ;
30658 int res2 = 0 ;
30659 void *argp3 = 0 ;
30660 int res3 = 0 ;
30661 PyObject * obj0 = 0 ;
30662 PyObject * obj1 = 0 ;
30663 PyObject * obj2 = 0 ;
30664 char * kwnames[] = {
30665 (char *) "self",(char *) "win",(char *) "event", NULL
30666 };
30667
30668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30670 if (!SWIG_IsOK(res1)) {
30671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30672 }
30673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30675 if (!SWIG_IsOK(res2)) {
30676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30677 }
30678 arg2 = reinterpret_cast< wxWindow * >(argp2);
30679 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30680 if (!SWIG_IsOK(res3)) {
30681 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30682 }
30683 if (!argp3) {
30684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30685 }
30686 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30687 {
30688 PyThreadState* __tstate = wxPyBeginAllowThreads();
30689 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30690 wxPyEndAllowThreads(__tstate);
30691 if (PyErr_Occurred()) SWIG_fail;
30692 }
30693 {
30694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30695 }
30696 return resultobj;
30697 fail:
30698 return NULL;
30699 }
30700
30701
30702 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30703 PyObject *resultobj = 0;
30704 wxPyApp *arg1 = (wxPyApp *) 0 ;
30705 bool result;
30706 void *argp1 = 0 ;
30707 int res1 = 0 ;
30708 PyObject *swig_obj[1] ;
30709
30710 if (!args) SWIG_fail;
30711 swig_obj[0] = args;
30712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30713 if (!SWIG_IsOK(res1)) {
30714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30715 }
30716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30717 {
30718 PyThreadState* __tstate = wxPyBeginAllowThreads();
30719 result = (bool)((wxPyApp const *)arg1)->IsActive();
30720 wxPyEndAllowThreads(__tstate);
30721 if (PyErr_Occurred()) SWIG_fail;
30722 }
30723 {
30724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30725 }
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj = 0;
30734 wxPyApp *arg1 = (wxPyApp *) 0 ;
30735 wxWindow *arg2 = (wxWindow *) 0 ;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 void *argp2 = 0 ;
30739 int res2 = 0 ;
30740 PyObject * obj0 = 0 ;
30741 PyObject * obj1 = 0 ;
30742 char * kwnames[] = {
30743 (char *) "self",(char *) "win", NULL
30744 };
30745
30746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30748 if (!SWIG_IsOK(res1)) {
30749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30750 }
30751 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30753 if (!SWIG_IsOK(res2)) {
30754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30755 }
30756 arg2 = reinterpret_cast< wxWindow * >(argp2);
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 (arg1)->SetTopWindow(arg2);
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 resultobj = SWIG_Py_Void();
30764 return resultobj;
30765 fail:
30766 return NULL;
30767 }
30768
30769
30770 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30771 PyObject *resultobj = 0;
30772 wxPyApp *arg1 = (wxPyApp *) 0 ;
30773 wxWindow *result = 0 ;
30774 void *argp1 = 0 ;
30775 int res1 = 0 ;
30776 PyObject *swig_obj[1] ;
30777
30778 if (!args) SWIG_fail;
30779 swig_obj[0] = args;
30780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30781 if (!SWIG_IsOK(res1)) {
30782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30783 }
30784 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30788 wxPyEndAllowThreads(__tstate);
30789 if (PyErr_Occurred()) SWIG_fail;
30790 }
30791 {
30792 resultobj = wxPyMake_wxObject(result, (bool)0);
30793 }
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30801 PyObject *resultobj = 0;
30802 wxPyApp *arg1 = (wxPyApp *) 0 ;
30803 bool arg2 ;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 bool val2 ;
30807 int ecode2 = 0 ;
30808 PyObject * obj0 = 0 ;
30809 PyObject * obj1 = 0 ;
30810 char * kwnames[] = {
30811 (char *) "self",(char *) "flag", NULL
30812 };
30813
30814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30816 if (!SWIG_IsOK(res1)) {
30817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30818 }
30819 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30821 if (!SWIG_IsOK(ecode2)) {
30822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30823 }
30824 arg2 = static_cast< bool >(val2);
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 (arg1)->SetExitOnFrameDelete(arg2);
30828 wxPyEndAllowThreads(__tstate);
30829 if (PyErr_Occurred()) SWIG_fail;
30830 }
30831 resultobj = SWIG_Py_Void();
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30839 PyObject *resultobj = 0;
30840 wxPyApp *arg1 = (wxPyApp *) 0 ;
30841 bool 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_wxPyApp, 0 | 0 );
30849 if (!SWIG_IsOK(res1)) {
30850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30851 }
30852 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 {
30860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30861 }
30862 return resultobj;
30863 fail:
30864 return NULL;
30865 }
30866
30867
30868 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30869 PyObject *resultobj = 0;
30870 wxPyApp *arg1 = (wxPyApp *) 0 ;
30871 bool arg2 ;
30872 void *argp1 = 0 ;
30873 int res1 = 0 ;
30874 bool val2 ;
30875 int ecode2 = 0 ;
30876 PyObject * obj0 = 0 ;
30877 PyObject * obj1 = 0 ;
30878 char * kwnames[] = {
30879 (char *) "self",(char *) "flag", NULL
30880 };
30881
30882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30884 if (!SWIG_IsOK(res1)) {
30885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30886 }
30887 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30889 if (!SWIG_IsOK(ecode2)) {
30890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30891 }
30892 arg2 = static_cast< bool >(val2);
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 (arg1)->SetUseBestVisual(arg2);
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 resultobj = SWIG_Py_Void();
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30907 PyObject *resultobj = 0;
30908 wxPyApp *arg1 = (wxPyApp *) 0 ;
30909 bool result;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 PyObject *swig_obj[1] ;
30913
30914 if (!args) SWIG_fail;
30915 swig_obj[0] = args;
30916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30917 if (!SWIG_IsOK(res1)) {
30918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30919 }
30920 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 {
30928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj = 0;
30938 wxPyApp *arg1 = (wxPyApp *) 0 ;
30939 int arg2 ;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 int val2 ;
30943 int ecode2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "mode", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30954 }
30955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30956 ecode2 = SWIG_AsVal_int(obj1, &val2);
30957 if (!SWIG_IsOK(ecode2)) {
30958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30959 }
30960 arg2 = static_cast< int >(val2);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 (arg1)->SetPrintMode(arg2);
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 resultobj = SWIG_Py_Void();
30968 return resultobj;
30969 fail:
30970 return NULL;
30971 }
30972
30973
30974 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30975 PyObject *resultobj = 0;
30976 wxPyApp *arg1 = (wxPyApp *) 0 ;
30977 int result;
30978 void *argp1 = 0 ;
30979 int res1 = 0 ;
30980 PyObject *swig_obj[1] ;
30981
30982 if (!args) SWIG_fail;
30983 swig_obj[0] = args;
30984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30987 }
30988 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_From_int(static_cast< int >(result));
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj = 0;
31004 wxPyApp *arg1 = (wxPyApp *) 0 ;
31005 int arg2 ;
31006 void *argp1 = 0 ;
31007 int res1 = 0 ;
31008 int val2 ;
31009 int ecode2 = 0 ;
31010 PyObject * obj0 = 0 ;
31011 PyObject * obj1 = 0 ;
31012 char * kwnames[] = {
31013 (char *) "self",(char *) "mode", NULL
31014 };
31015
31016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31018 if (!SWIG_IsOK(res1)) {
31019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31020 }
31021 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31022 ecode2 = SWIG_AsVal_int(obj1, &val2);
31023 if (!SWIG_IsOK(ecode2)) {
31024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31025 }
31026 arg2 = static_cast< int >(val2);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 (arg1)->SetAssertMode(arg2);
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_Py_Void();
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxPyApp *arg1 = (wxPyApp *) 0 ;
31043 int result;
31044 void *argp1 = 0 ;
31045 int res1 = 0 ;
31046 PyObject *swig_obj[1] ;
31047
31048 if (!args) SWIG_fail;
31049 swig_obj[0] = args;
31050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31051 if (!SWIG_IsOK(res1)) {
31052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31053 }
31054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = (int)(arg1)->GetAssertMode();
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_From_int(static_cast< int >(result));
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31069 PyObject *resultobj = 0;
31070 bool result;
31071
31072 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 {
31080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31081 }
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 long result;
31091
31092 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 result = (long)wxPyApp::GetMacAboutMenuItemId();
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 resultobj = SWIG_From_long(static_cast< long >(result));
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31107 PyObject *resultobj = 0;
31108 long result;
31109
31110 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 resultobj = SWIG_From_long(static_cast< long >(result));
31118 return resultobj;
31119 fail:
31120 return NULL;
31121 }
31122
31123
31124 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31125 PyObject *resultobj = 0;
31126 long result;
31127
31128 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 result = (long)wxPyApp::GetMacExitMenuItemId();
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_From_long(static_cast< long >(result));
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31143 PyObject *resultobj = 0;
31144 wxString result;
31145
31146 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = wxPyApp::GetMacHelpMenuTitleName();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 {
31154 #if wxUSE_UNICODE
31155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31156 #else
31157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31158 #endif
31159 }
31160 return resultobj;
31161 fail:
31162 return NULL;
31163 }
31164
31165
31166 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31167 PyObject *resultobj = 0;
31168 bool arg1 ;
31169 bool val1 ;
31170 int ecode1 = 0 ;
31171 PyObject * obj0 = 0 ;
31172 char * kwnames[] = {
31173 (char *) "val", NULL
31174 };
31175
31176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31177 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31178 if (!SWIG_IsOK(ecode1)) {
31179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31180 }
31181 arg1 = static_cast< bool >(val1);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = SWIG_Py_Void();
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj = 0;
31197 long arg1 ;
31198 long val1 ;
31199 int ecode1 = 0 ;
31200 PyObject * obj0 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "val", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31206 ecode1 = SWIG_AsVal_long(obj0, &val1);
31207 if (!SWIG_IsOK(ecode1)) {
31208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31209 }
31210 arg1 = static_cast< long >(val1);
31211 {
31212 PyThreadState* __tstate = wxPyBeginAllowThreads();
31213 wxPyApp::SetMacAboutMenuItemId(arg1);
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 resultobj = SWIG_Py_Void();
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj = 0;
31226 long arg1 ;
31227 long val1 ;
31228 int ecode1 = 0 ;
31229 PyObject * obj0 = 0 ;
31230 char * kwnames[] = {
31231 (char *) "val", NULL
31232 };
31233
31234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31235 ecode1 = SWIG_AsVal_long(obj0, &val1);
31236 if (!SWIG_IsOK(ecode1)) {
31237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31238 }
31239 arg1 = static_cast< long >(val1);
31240 {
31241 PyThreadState* __tstate = wxPyBeginAllowThreads();
31242 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 resultobj = SWIG_Py_Void();
31247 return resultobj;
31248 fail:
31249 return NULL;
31250 }
31251
31252
31253 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31254 PyObject *resultobj = 0;
31255 long arg1 ;
31256 long val1 ;
31257 int ecode1 = 0 ;
31258 PyObject * obj0 = 0 ;
31259 char * kwnames[] = {
31260 (char *) "val", NULL
31261 };
31262
31263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31264 ecode1 = SWIG_AsVal_long(obj0, &val1);
31265 if (!SWIG_IsOK(ecode1)) {
31266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31267 }
31268 arg1 = static_cast< long >(val1);
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 wxPyApp::SetMacExitMenuItemId(arg1);
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_Py_Void();
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj = 0;
31284 wxString *arg1 = 0 ;
31285 bool temp1 = false ;
31286 PyObject * obj0 = 0 ;
31287 char * kwnames[] = {
31288 (char *) "val", NULL
31289 };
31290
31291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31292 {
31293 arg1 = wxString_in_helper(obj0);
31294 if (arg1 == NULL) SWIG_fail;
31295 temp1 = true;
31296 }
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_Py_Void();
31304 {
31305 if (temp1)
31306 delete arg1;
31307 }
31308 return resultobj;
31309 fail:
31310 {
31311 if (temp1)
31312 delete arg1;
31313 }
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31319 PyObject *resultobj = 0;
31320 wxPyApp *arg1 = (wxPyApp *) 0 ;
31321 void *argp1 = 0 ;
31322 int res1 = 0 ;
31323 PyObject *swig_obj[1] ;
31324
31325 if (!args) SWIG_fail;
31326 swig_obj[0] = args;
31327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31328 if (!SWIG_IsOK(res1)) {
31329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31330 }
31331 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 (arg1)->_BootstrapApp();
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 resultobj = SWIG_Py_Void();
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31346 PyObject *resultobj = 0;
31347 int result;
31348
31349 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (int)wxPyApp_GetComCtl32Version();
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 resultobj = SWIG_From_int(static_cast< int >(result));
31357 return resultobj;
31358 fail:
31359 return NULL;
31360 }
31361
31362
31363 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31364 PyObject *resultobj = 0;
31365 bool result;
31366
31367 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = (bool)wxPyApp_IsDisplayAvailable();
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 {
31375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31376 }
31377 return resultobj;
31378 fail:
31379 return NULL;
31380 }
31381
31382
31383 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31384 PyObject *obj;
31385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31386 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31387 return SWIG_Py_Void();
31388 }
31389
31390 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31391 return SWIG_Python_InitShadowInstance(args);
31392 }
31393
31394 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31395 PyObject *resultobj = 0;
31396
31397 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 wxExit();
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 resultobj = SWIG_Py_Void();
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31412 PyObject *resultobj = 0;
31413 bool result;
31414
31415 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = (bool)wxYield();
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 {
31423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31424 }
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31432 PyObject *resultobj = 0;
31433 bool result;
31434
31435 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 result = (bool)wxYieldIfNeeded();
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 {
31443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31444 }
31445 return resultobj;
31446 fail:
31447 return NULL;
31448 }
31449
31450
31451 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31452 PyObject *resultobj = 0;
31453 wxWindow *arg1 = (wxWindow *) NULL ;
31454 bool arg2 = (bool) false ;
31455 bool result;
31456 void *argp1 = 0 ;
31457 int res1 = 0 ;
31458 bool val2 ;
31459 int ecode2 = 0 ;
31460 PyObject * obj0 = 0 ;
31461 PyObject * obj1 = 0 ;
31462 char * kwnames[] = {
31463 (char *) "win",(char *) "onlyIfNeeded", NULL
31464 };
31465
31466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31467 if (obj0) {
31468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31469 if (!SWIG_IsOK(res1)) {
31470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31471 }
31472 arg1 = reinterpret_cast< wxWindow * >(argp1);
31473 }
31474 if (obj1) {
31475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31476 if (!SWIG_IsOK(ecode2)) {
31477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31478 }
31479 arg2 = static_cast< bool >(val2);
31480 }
31481 {
31482 PyThreadState* __tstate = wxPyBeginAllowThreads();
31483 result = (bool)wxSafeYield(arg1,arg2);
31484 wxPyEndAllowThreads(__tstate);
31485 if (PyErr_Occurred()) SWIG_fail;
31486 }
31487 {
31488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31489 }
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31497 PyObject *resultobj = 0;
31498
31499 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31500 {
31501 PyThreadState* __tstate = wxPyBeginAllowThreads();
31502 wxWakeUpIdle();
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 resultobj = SWIG_Py_Void();
31507 return resultobj;
31508 fail:
31509 return NULL;
31510 }
31511
31512
31513 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31514 PyObject *resultobj = 0;
31515 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31516 wxEvent *arg2 = 0 ;
31517 void *argp1 = 0 ;
31518 int res1 = 0 ;
31519 void *argp2 = 0 ;
31520 int res2 = 0 ;
31521 PyObject * obj0 = 0 ;
31522 PyObject * obj1 = 0 ;
31523 char * kwnames[] = {
31524 (char *) "dest",(char *) "event", NULL
31525 };
31526
31527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31529 if (!SWIG_IsOK(res1)) {
31530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31531 }
31532 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31534 if (!SWIG_IsOK(res2)) {
31535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31536 }
31537 if (!argp2) {
31538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31539 }
31540 arg2 = reinterpret_cast< wxEvent * >(argp2);
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 wxPostEvent(arg1,*arg2);
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 resultobj = SWIG_Py_Void();
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556
31557 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31558 {
31559 PyThreadState* __tstate = wxPyBeginAllowThreads();
31560 wxApp_CleanUp();
31561 wxPyEndAllowThreads(__tstate);
31562 if (PyErr_Occurred()) SWIG_fail;
31563 }
31564 resultobj = SWIG_Py_Void();
31565 return resultobj;
31566 fail:
31567 return NULL;
31568 }
31569
31570
31571 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31572 PyObject *resultobj = 0;
31573 wxPyApp *result = 0 ;
31574
31575 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31576 {
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 result = (wxPyApp *)wxPyGetApp();
31579 wxPyEndAllowThreads(__tstate);
31580 if (PyErr_Occurred()) SWIG_fail;
31581 }
31582 {
31583 resultobj = wxPyMake_wxObject(result, 0);
31584 }
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = 0;
31593 char *arg1 = (char *) 0 ;
31594 int res1 ;
31595 char *buf1 = 0 ;
31596 int alloc1 = 0 ;
31597 PyObject * obj0 = 0 ;
31598 char * kwnames[] = {
31599 (char *) "encoding", NULL
31600 };
31601
31602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31603 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31604 if (!SWIG_IsOK(res1)) {
31605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31606 }
31607 arg1 = buf1;
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 wxSetDefaultPyEncoding((char const *)arg1);
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 resultobj = SWIG_Py_Void();
31615 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31616 return resultobj;
31617 fail:
31618 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31619 return NULL;
31620 }
31621
31622
31623 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31624 PyObject *resultobj = 0;
31625 char *result = 0 ;
31626
31627 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31628 {
31629 PyThreadState* __tstate = wxPyBeginAllowThreads();
31630 result = (char *)wxGetDefaultPyEncoding();
31631 wxPyEndAllowThreads(__tstate);
31632 if (PyErr_Occurred()) SWIG_fail;
31633 }
31634 resultobj = SWIG_FromCharPtr(result);
31635 return resultobj;
31636 fail:
31637 return NULL;
31638 }
31639
31640
31641 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31642 PyObject *resultobj = 0;
31643 wxEventLoop *result = 0 ;
31644
31645 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 result = (wxEventLoop *)new wxEventLoop();
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31662 void *argp1 = 0 ;
31663 int res1 = 0 ;
31664 PyObject *swig_obj[1] ;
31665
31666 if (!args) SWIG_fail;
31667 swig_obj[0] = args;
31668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31669 if (!SWIG_IsOK(res1)) {
31670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31671 }
31672 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31673 {
31674 PyThreadState* __tstate = wxPyBeginAllowThreads();
31675 delete arg1;
31676
31677 wxPyEndAllowThreads(__tstate);
31678 if (PyErr_Occurred()) SWIG_fail;
31679 }
31680 resultobj = SWIG_Py_Void();
31681 return resultobj;
31682 fail:
31683 return NULL;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31688 PyObject *resultobj = 0;
31689 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31690 int result;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 PyObject *swig_obj[1] ;
31694
31695 if (!args) SWIG_fail;
31696 swig_obj[0] = args;
31697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31698 if (!SWIG_IsOK(res1)) {
31699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31700 }
31701 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 result = (int)(arg1)->Run();
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_From_int(static_cast< int >(result));
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj = 0;
31717 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31718 int arg2 = (int) 0 ;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 int val2 ;
31722 int ecode2 = 0 ;
31723 PyObject * obj0 = 0 ;
31724 PyObject * obj1 = 0 ;
31725 char * kwnames[] = {
31726 (char *) "self",(char *) "rc", NULL
31727 };
31728
31729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31733 }
31734 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31735 if (obj1) {
31736 ecode2 = SWIG_AsVal_int(obj1, &val2);
31737 if (!SWIG_IsOK(ecode2)) {
31738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31739 }
31740 arg2 = static_cast< int >(val2);
31741 }
31742 {
31743 PyThreadState* __tstate = wxPyBeginAllowThreads();
31744 (arg1)->Exit(arg2);
31745 wxPyEndAllowThreads(__tstate);
31746 if (PyErr_Occurred()) SWIG_fail;
31747 }
31748 resultobj = SWIG_Py_Void();
31749 return resultobj;
31750 fail:
31751 return NULL;
31752 }
31753
31754
31755 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31756 PyObject *resultobj = 0;
31757 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31758 bool result;
31759 void *argp1 = 0 ;
31760 int res1 = 0 ;
31761 PyObject *swig_obj[1] ;
31762
31763 if (!args) SWIG_fail;
31764 swig_obj[0] = args;
31765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31766 if (!SWIG_IsOK(res1)) {
31767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31768 }
31769 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31770 {
31771 PyThreadState* __tstate = wxPyBeginAllowThreads();
31772 result = (bool)((wxEventLoop const *)arg1)->Pending();
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 {
31777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31778 }
31779 return resultobj;
31780 fail:
31781 return NULL;
31782 }
31783
31784
31785 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31786 PyObject *resultobj = 0;
31787 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31788 bool result;
31789 void *argp1 = 0 ;
31790 int res1 = 0 ;
31791 PyObject *swig_obj[1] ;
31792
31793 if (!args) SWIG_fail;
31794 swig_obj[0] = args;
31795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31796 if (!SWIG_IsOK(res1)) {
31797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31798 }
31799 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 result = (bool)(arg1)->Dispatch();
31803 wxPyEndAllowThreads(__tstate);
31804 if (PyErr_Occurred()) SWIG_fail;
31805 }
31806 {
31807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31808 }
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31818 bool result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 PyObject *swig_obj[1] ;
31822
31823 if (!args) SWIG_fail;
31824 swig_obj[0] = args;
31825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31828 }
31829 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 {
31837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31838 }
31839 return resultobj;
31840 fail:
31841 return NULL;
31842 }
31843
31844
31845 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31846 PyObject *resultobj = 0;
31847 wxEventLoop *result = 0 ;
31848
31849 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 result = (wxEventLoop *)wxEventLoop::GetActive();
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31866 void *argp1 = 0 ;
31867 int res1 = 0 ;
31868 PyObject * obj0 = 0 ;
31869 char * kwnames[] = {
31870 (char *) "loop", NULL
31871 };
31872
31873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31875 if (!SWIG_IsOK(res1)) {
31876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31877 }
31878 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31879 {
31880 PyThreadState* __tstate = wxPyBeginAllowThreads();
31881 wxEventLoop::SetActive(arg1);
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 resultobj = SWIG_Py_Void();
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31893 PyObject *obj;
31894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31895 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31896 return SWIG_Py_Void();
31897 }
31898
31899 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 return SWIG_Python_InitShadowInstance(args);
31901 }
31902
31903 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31904 PyObject *resultobj = 0;
31905 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31906 wxEventLoopActivator *result = 0 ;
31907 void *argp1 = 0 ;
31908 int res1 = 0 ;
31909 PyObject * obj0 = 0 ;
31910 char * kwnames[] = {
31911 (char *) "evtLoop", NULL
31912 };
31913
31914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31916 if (!SWIG_IsOK(res1)) {
31917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31918 }
31919 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31920 {
31921 PyThreadState* __tstate = wxPyBeginAllowThreads();
31922 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31923 wxPyEndAllowThreads(__tstate);
31924 if (PyErr_Occurred()) SWIG_fail;
31925 }
31926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31927 return resultobj;
31928 fail:
31929 return NULL;
31930 }
31931
31932
31933 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31934 PyObject *resultobj = 0;
31935 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31936 void *argp1 = 0 ;
31937 int res1 = 0 ;
31938 PyObject *swig_obj[1] ;
31939
31940 if (!args) SWIG_fail;
31941 swig_obj[0] = args;
31942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31943 if (!SWIG_IsOK(res1)) {
31944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31945 }
31946 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31947 {
31948 PyThreadState* __tstate = wxPyBeginAllowThreads();
31949 delete arg1;
31950
31951 wxPyEndAllowThreads(__tstate);
31952 if (PyErr_Occurred()) SWIG_fail;
31953 }
31954 resultobj = SWIG_Py_Void();
31955 return resultobj;
31956 fail:
31957 return NULL;
31958 }
31959
31960
31961 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31962 PyObject *obj;
31963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31964 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31965 return SWIG_Py_Void();
31966 }
31967
31968 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31969 return SWIG_Python_InitShadowInstance(args);
31970 }
31971
31972 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj = 0;
31974 int arg1 = (int) 0 ;
31975 int arg2 = (int) 0 ;
31976 int arg3 = (int) 0 ;
31977 wxAcceleratorEntry *result = 0 ;
31978 int val1 ;
31979 int ecode1 = 0 ;
31980 int val2 ;
31981 int ecode2 = 0 ;
31982 int val3 ;
31983 int ecode3 = 0 ;
31984 PyObject * obj0 = 0 ;
31985 PyObject * obj1 = 0 ;
31986 PyObject * obj2 = 0 ;
31987 char * kwnames[] = {
31988 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31989 };
31990
31991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31992 if (obj0) {
31993 ecode1 = SWIG_AsVal_int(obj0, &val1);
31994 if (!SWIG_IsOK(ecode1)) {
31995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31996 }
31997 arg1 = static_cast< int >(val1);
31998 }
31999 if (obj1) {
32000 ecode2 = SWIG_AsVal_int(obj1, &val2);
32001 if (!SWIG_IsOK(ecode2)) {
32002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32003 }
32004 arg2 = static_cast< int >(val2);
32005 }
32006 if (obj2) {
32007 ecode3 = SWIG_AsVal_int(obj2, &val3);
32008 if (!SWIG_IsOK(ecode3)) {
32009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32010 }
32011 arg3 = static_cast< int >(val3);
32012 }
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32027 PyObject *resultobj = 0;
32028 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32029 void *argp1 = 0 ;
32030 int res1 = 0 ;
32031 PyObject *swig_obj[1] ;
32032
32033 if (!args) SWIG_fail;
32034 swig_obj[0] = args;
32035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32036 if (!SWIG_IsOK(res1)) {
32037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32038 }
32039 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32040 {
32041 PyThreadState* __tstate = wxPyBeginAllowThreads();
32042 delete arg1;
32043
32044 wxPyEndAllowThreads(__tstate);
32045 if (PyErr_Occurred()) SWIG_fail;
32046 }
32047 resultobj = SWIG_Py_Void();
32048 return resultobj;
32049 fail:
32050 return NULL;
32051 }
32052
32053
32054 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32055 PyObject *resultobj = 0;
32056 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32057 int arg2 ;
32058 int arg3 ;
32059 int arg4 ;
32060 void *argp1 = 0 ;
32061 int res1 = 0 ;
32062 int val2 ;
32063 int ecode2 = 0 ;
32064 int val3 ;
32065 int ecode3 = 0 ;
32066 int val4 ;
32067 int ecode4 = 0 ;
32068 PyObject * obj0 = 0 ;
32069 PyObject * obj1 = 0 ;
32070 PyObject * obj2 = 0 ;
32071 PyObject * obj3 = 0 ;
32072 char * kwnames[] = {
32073 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32074 };
32075
32076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32078 if (!SWIG_IsOK(res1)) {
32079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32080 }
32081 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32082 ecode2 = SWIG_AsVal_int(obj1, &val2);
32083 if (!SWIG_IsOK(ecode2)) {
32084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32085 }
32086 arg2 = static_cast< int >(val2);
32087 ecode3 = SWIG_AsVal_int(obj2, &val3);
32088 if (!SWIG_IsOK(ecode3)) {
32089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32090 }
32091 arg3 = static_cast< int >(val3);
32092 ecode4 = SWIG_AsVal_int(obj3, &val4);
32093 if (!SWIG_IsOK(ecode4)) {
32094 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32095 }
32096 arg4 = static_cast< int >(val4);
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 (arg1)->Set(arg2,arg3,arg4);
32100 wxPyEndAllowThreads(__tstate);
32101 if (PyErr_Occurred()) SWIG_fail;
32102 }
32103 resultobj = SWIG_Py_Void();
32104 return resultobj;
32105 fail:
32106 return NULL;
32107 }
32108
32109
32110 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32111 PyObject *resultobj = 0;
32112 wxString *arg1 = 0 ;
32113 wxAcceleratorEntry *result = 0 ;
32114 bool temp1 = false ;
32115 PyObject * obj0 = 0 ;
32116 char * kwnames[] = {
32117 (char *) "str", NULL
32118 };
32119
32120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32121 {
32122 arg1 = wxString_in_helper(obj0);
32123 if (arg1 == NULL) SWIG_fail;
32124 temp1 = true;
32125 }
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32133 {
32134 if (temp1)
32135 delete arg1;
32136 }
32137 return resultobj;
32138 fail:
32139 {
32140 if (temp1)
32141 delete arg1;
32142 }
32143 return NULL;
32144 }
32145
32146
32147 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32148 PyObject *resultobj = 0;
32149 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32150 int result;
32151 void *argp1 = 0 ;
32152 int res1 = 0 ;
32153 PyObject *swig_obj[1] ;
32154
32155 if (!args) SWIG_fail;
32156 swig_obj[0] = args;
32157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32158 if (!SWIG_IsOK(res1)) {
32159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32160 }
32161 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (int)(arg1)->GetFlags();
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = SWIG_From_int(static_cast< int >(result));
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32176 PyObject *resultobj = 0;
32177 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32178 int result;
32179 void *argp1 = 0 ;
32180 int res1 = 0 ;
32181 PyObject *swig_obj[1] ;
32182
32183 if (!args) SWIG_fail;
32184 swig_obj[0] = args;
32185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32188 }
32189 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = (int)(arg1)->GetKeyCode();
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_From_int(static_cast< int >(result));
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32206 int result;
32207 void *argp1 = 0 ;
32208 int res1 = 0 ;
32209 PyObject *swig_obj[1] ;
32210
32211 if (!args) SWIG_fail;
32212 swig_obj[0] = args;
32213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32216 }
32217 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 result = (int)(arg1)->GetCommand();
32221 wxPyEndAllowThreads(__tstate);
32222 if (PyErr_Occurred()) SWIG_fail;
32223 }
32224 resultobj = SWIG_From_int(static_cast< int >(result));
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232 PyObject *resultobj = 0;
32233 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32234 bool result;
32235 void *argp1 = 0 ;
32236 int res1 = 0 ;
32237 PyObject *swig_obj[1] ;
32238
32239 if (!args) SWIG_fail;
32240 swig_obj[0] = args;
32241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32244 }
32245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32254 }
32255 return resultobj;
32256 fail:
32257 return NULL;
32258 }
32259
32260
32261 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32262 PyObject *resultobj = 0;
32263 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32264 wxString result;
32265 void *argp1 = 0 ;
32266 int res1 = 0 ;
32267 PyObject *swig_obj[1] ;
32268
32269 if (!args) SWIG_fail;
32270 swig_obj[0] = args;
32271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32272 if (!SWIG_IsOK(res1)) {
32273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32274 }
32275 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 #if wxUSE_UNICODE
32284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32285 #else
32286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32287 #endif
32288 }
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj = 0;
32297 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32298 wxString *arg2 = 0 ;
32299 bool result;
32300 void *argp1 = 0 ;
32301 int res1 = 0 ;
32302 bool temp2 = false ;
32303 PyObject * obj0 = 0 ;
32304 PyObject * obj1 = 0 ;
32305 char * kwnames[] = {
32306 (char *) "self",(char *) "str", NULL
32307 };
32308
32309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32311 if (!SWIG_IsOK(res1)) {
32312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32313 }
32314 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32315 {
32316 arg2 = wxString_in_helper(obj1);
32317 if (arg2 == NULL) SWIG_fail;
32318 temp2 = true;
32319 }
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 {
32327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32328 }
32329 {
32330 if (temp2)
32331 delete arg2;
32332 }
32333 return resultobj;
32334 fail:
32335 {
32336 if (temp2)
32337 delete arg2;
32338 }
32339 return NULL;
32340 }
32341
32342
32343 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344 PyObject *obj;
32345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32346 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32347 return SWIG_Py_Void();
32348 }
32349
32350 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 return SWIG_Python_InitShadowInstance(args);
32352 }
32353
32354 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32355 PyObject *resultobj = 0;
32356 int arg1 ;
32357 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32358 wxAcceleratorTable *result = 0 ;
32359 PyObject * obj0 = 0 ;
32360 char * kwnames[] = {
32361 (char *) "n", NULL
32362 };
32363
32364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32365 {
32366 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32367 if (arg2) arg1 = PyList_Size(obj0);
32368 else arg1 = 0;
32369 }
32370 {
32371 PyThreadState* __tstate = wxPyBeginAllowThreads();
32372 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32373 wxPyEndAllowThreads(__tstate);
32374 if (PyErr_Occurred()) SWIG_fail;
32375 }
32376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32377 return resultobj;
32378 fail:
32379 return NULL;
32380 }
32381
32382
32383 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32384 PyObject *resultobj = 0;
32385 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32386 void *argp1 = 0 ;
32387 int res1 = 0 ;
32388 PyObject *swig_obj[1] ;
32389
32390 if (!args) SWIG_fail;
32391 swig_obj[0] = args;
32392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32393 if (!SWIG_IsOK(res1)) {
32394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32395 }
32396 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 delete arg1;
32400
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_Py_Void();
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32412 PyObject *resultobj = 0;
32413 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32414 bool result;
32415 void *argp1 = 0 ;
32416 int res1 = 0 ;
32417 PyObject *swig_obj[1] ;
32418
32419 if (!args) SWIG_fail;
32420 swig_obj[0] = args;
32421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32422 if (!SWIG_IsOK(res1)) {
32423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32424 }
32425 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 {
32433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 PyObject *obj;
32443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32444 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32445 return SWIG_Py_Void();
32446 }
32447
32448 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32449 return SWIG_Python_InitShadowInstance(args);
32450 }
32451
32452 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32453 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32454 return 1;
32455 }
32456
32457
32458 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32459 PyObject *pyobj = 0;
32460
32461 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32462 return pyobj;
32463 }
32464
32465
32466 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32467 PyObject *resultobj = 0;
32468 wxString *arg1 = 0 ;
32469 wxAcceleratorEntry *result = 0 ;
32470 bool temp1 = false ;
32471 PyObject * obj0 = 0 ;
32472 char * kwnames[] = {
32473 (char *) "label", NULL
32474 };
32475
32476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32477 {
32478 arg1 = wxString_in_helper(obj0);
32479 if (arg1 == NULL) SWIG_fail;
32480 temp1 = true;
32481 }
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32489 {
32490 if (temp1)
32491 delete arg1;
32492 }
32493 return resultobj;
32494 fail:
32495 {
32496 if (temp1)
32497 delete arg1;
32498 }
32499 return NULL;
32500 }
32501
32502
32503 SWIGINTERN int PanelNameStr_set(PyObject *) {
32504 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32505 return 1;
32506 }
32507
32508
32509 SWIGINTERN PyObject *PanelNameStr_get(void) {
32510 PyObject *pyobj = 0;
32511
32512 {
32513 #if wxUSE_UNICODE
32514 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32515 #else
32516 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32517 #endif
32518 }
32519 return pyobj;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 PyObject *resultobj = 0;
32525 wxVisualAttributes *result = 0 ;
32526
32527 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32528 {
32529 PyThreadState* __tstate = wxPyBeginAllowThreads();
32530 result = (wxVisualAttributes *)new_wxVisualAttributes();
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32535 return resultobj;
32536 fail:
32537 return NULL;
32538 }
32539
32540
32541 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32542 PyObject *resultobj = 0;
32543 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32544 void *argp1 = 0 ;
32545 int res1 = 0 ;
32546 PyObject *swig_obj[1] ;
32547
32548 if (!args) SWIG_fail;
32549 swig_obj[0] = args;
32550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32551 if (!SWIG_IsOK(res1)) {
32552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32553 }
32554 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 delete_wxVisualAttributes(arg1);
32558
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 resultobj = SWIG_Py_Void();
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 PyObject *resultobj = 0;
32571 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32572 wxFont *arg2 = (wxFont *) 0 ;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 void *argp2 = 0 ;
32576 int res2 = 0 ;
32577 PyObject *swig_obj[2] ;
32578
32579 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32583 }
32584 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32586 if (!SWIG_IsOK(res2)) {
32587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32588 }
32589 arg2 = reinterpret_cast< wxFont * >(argp2);
32590 if (arg1) (arg1)->font = *arg2;
32591
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32602 wxFont *result = 0 ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 PyObject *swig_obj[1] ;
32606
32607 if (!args) SWIG_fail;
32608 swig_obj[0] = args;
32609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32612 }
32613 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32614 result = (wxFont *)& ((arg1)->font);
32615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *resultobj = 0;
32624 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32625 wxColour *arg2 = (wxColour *) 0 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 void *argp2 = 0 ;
32629 int res2 = 0 ;
32630 PyObject *swig_obj[2] ;
32631
32632 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32636 }
32637 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32639 if (!SWIG_IsOK(res2)) {
32640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32641 }
32642 arg2 = reinterpret_cast< wxColour * >(argp2);
32643 if (arg1) (arg1)->colFg = *arg2;
32644
32645 resultobj = SWIG_Py_Void();
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32655 wxColour *result = 0 ;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32665 }
32666 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32667 result = (wxColour *)& ((arg1)->colFg);
32668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *resultobj = 0;
32677 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32678 wxColour *arg2 = (wxColour *) 0 ;
32679 void *argp1 = 0 ;
32680 int res1 = 0 ;
32681 void *argp2 = 0 ;
32682 int res2 = 0 ;
32683 PyObject *swig_obj[2] ;
32684
32685 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32687 if (!SWIG_IsOK(res1)) {
32688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32689 }
32690 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32691 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32692 if (!SWIG_IsOK(res2)) {
32693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32694 }
32695 arg2 = reinterpret_cast< wxColour * >(argp2);
32696 if (arg1) (arg1)->colBg = *arg2;
32697
32698 resultobj = SWIG_Py_Void();
32699 return resultobj;
32700 fail:
32701 return NULL;
32702 }
32703
32704
32705 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32706 PyObject *resultobj = 0;
32707 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32708 wxColour *result = 0 ;
32709 void *argp1 = 0 ;
32710 int res1 = 0 ;
32711 PyObject *swig_obj[1] ;
32712
32713 if (!args) SWIG_fail;
32714 swig_obj[0] = args;
32715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32716 if (!SWIG_IsOK(res1)) {
32717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32718 }
32719 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32720 result = (wxColour *)& ((arg1)->colBg);
32721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32729 PyObject *obj;
32730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32731 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32732 return SWIG_Py_Void();
32733 }
32734
32735 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32736 return SWIG_Python_InitShadowInstance(args);
32737 }
32738
32739 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32740 PyObject *resultobj = 0;
32741 wxWindow *arg1 = (wxWindow *) 0 ;
32742 int arg2 = (int) (int)-1 ;
32743 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32744 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32745 wxSize const &arg4_defvalue = wxDefaultSize ;
32746 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32747 long arg5 = (long) 0 ;
32748 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32749 wxString *arg6 = (wxString *) &arg6_defvalue ;
32750 wxWindow *result = 0 ;
32751 void *argp1 = 0 ;
32752 int res1 = 0 ;
32753 int val2 ;
32754 int ecode2 = 0 ;
32755 wxPoint temp3 ;
32756 wxSize temp4 ;
32757 long val5 ;
32758 int ecode5 = 0 ;
32759 bool temp6 = false ;
32760 PyObject * obj0 = 0 ;
32761 PyObject * obj1 = 0 ;
32762 PyObject * obj2 = 0 ;
32763 PyObject * obj3 = 0 ;
32764 PyObject * obj4 = 0 ;
32765 PyObject * obj5 = 0 ;
32766 char * kwnames[] = {
32767 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32768 };
32769
32770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32772 if (!SWIG_IsOK(res1)) {
32773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32774 }
32775 arg1 = reinterpret_cast< wxWindow * >(argp1);
32776 if (obj1) {
32777 ecode2 = SWIG_AsVal_int(obj1, &val2);
32778 if (!SWIG_IsOK(ecode2)) {
32779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32780 }
32781 arg2 = static_cast< int >(val2);
32782 }
32783 if (obj2) {
32784 {
32785 arg3 = &temp3;
32786 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32787 }
32788 }
32789 if (obj3) {
32790 {
32791 arg4 = &temp4;
32792 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32793 }
32794 }
32795 if (obj4) {
32796 ecode5 = SWIG_AsVal_long(obj4, &val5);
32797 if (!SWIG_IsOK(ecode5)) {
32798 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32799 }
32800 arg5 = static_cast< long >(val5);
32801 }
32802 if (obj5) {
32803 {
32804 arg6 = wxString_in_helper(obj5);
32805 if (arg6 == NULL) SWIG_fail;
32806 temp6 = true;
32807 }
32808 }
32809 {
32810 if (!wxPyCheckForApp()) SWIG_fail;
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32817 {
32818 if (temp6)
32819 delete arg6;
32820 }
32821 return resultobj;
32822 fail:
32823 {
32824 if (temp6)
32825 delete arg6;
32826 }
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxWindow *result = 0 ;
32834
32835 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32836 {
32837 if (!wxPyCheckForApp()) SWIG_fail;
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 result = (wxWindow *)new wxWindow();
32840 wxPyEndAllowThreads(__tstate);
32841 if (PyErr_Occurred()) SWIG_fail;
32842 }
32843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj = 0;
32852 wxWindow *arg1 = (wxWindow *) 0 ;
32853 wxWindow *arg2 = (wxWindow *) 0 ;
32854 int arg3 = (int) (int)-1 ;
32855 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32856 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32857 wxSize const &arg5_defvalue = wxDefaultSize ;
32858 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32859 long arg6 = (long) 0 ;
32860 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32861 wxString *arg7 = (wxString *) &arg7_defvalue ;
32862 bool result;
32863 void *argp1 = 0 ;
32864 int res1 = 0 ;
32865 void *argp2 = 0 ;
32866 int res2 = 0 ;
32867 int val3 ;
32868 int ecode3 = 0 ;
32869 wxPoint temp4 ;
32870 wxSize temp5 ;
32871 long val6 ;
32872 int ecode6 = 0 ;
32873 bool temp7 = false ;
32874 PyObject * obj0 = 0 ;
32875 PyObject * obj1 = 0 ;
32876 PyObject * obj2 = 0 ;
32877 PyObject * obj3 = 0 ;
32878 PyObject * obj4 = 0 ;
32879 PyObject * obj5 = 0 ;
32880 PyObject * obj6 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32889 }
32890 arg1 = reinterpret_cast< wxWindow * >(argp1);
32891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32892 if (!SWIG_IsOK(res2)) {
32893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32894 }
32895 arg2 = reinterpret_cast< wxWindow * >(argp2);
32896 if (obj2) {
32897 ecode3 = SWIG_AsVal_int(obj2, &val3);
32898 if (!SWIG_IsOK(ecode3)) {
32899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32900 }
32901 arg3 = static_cast< int >(val3);
32902 }
32903 if (obj3) {
32904 {
32905 arg4 = &temp4;
32906 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32907 }
32908 }
32909 if (obj4) {
32910 {
32911 arg5 = &temp5;
32912 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32913 }
32914 }
32915 if (obj5) {
32916 ecode6 = SWIG_AsVal_long(obj5, &val6);
32917 if (!SWIG_IsOK(ecode6)) {
32918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32919 }
32920 arg6 = static_cast< long >(val6);
32921 }
32922 if (obj6) {
32923 {
32924 arg7 = wxString_in_helper(obj6);
32925 if (arg7 == NULL) SWIG_fail;
32926 temp7 = true;
32927 }
32928 }
32929 {
32930 PyThreadState* __tstate = wxPyBeginAllowThreads();
32931 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32932 wxPyEndAllowThreads(__tstate);
32933 if (PyErr_Occurred()) SWIG_fail;
32934 }
32935 {
32936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32937 }
32938 {
32939 if (temp7)
32940 delete arg7;
32941 }
32942 return resultobj;
32943 fail:
32944 {
32945 if (temp7)
32946 delete arg7;
32947 }
32948 return NULL;
32949 }
32950
32951
32952 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj = 0;
32954 wxWindow *arg1 = (wxWindow *) 0 ;
32955 bool arg2 = (bool) false ;
32956 bool result;
32957 void *argp1 = 0 ;
32958 int res1 = 0 ;
32959 bool val2 ;
32960 int ecode2 = 0 ;
32961 PyObject * obj0 = 0 ;
32962 PyObject * obj1 = 0 ;
32963 char * kwnames[] = {
32964 (char *) "self",(char *) "force", NULL
32965 };
32966
32967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32969 if (!SWIG_IsOK(res1)) {
32970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32971 }
32972 arg1 = reinterpret_cast< wxWindow * >(argp1);
32973 if (obj1) {
32974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32975 if (!SWIG_IsOK(ecode2)) {
32976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32977 }
32978 arg2 = static_cast< bool >(val2);
32979 }
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 result = (bool)(arg1)->Close(arg2);
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 {
32987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32988 }
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32996 PyObject *resultobj = 0;
32997 wxWindow *arg1 = (wxWindow *) 0 ;
32998 bool result;
32999 void *argp1 = 0 ;
33000 int res1 = 0 ;
33001 PyObject *swig_obj[1] ;
33002
33003 if (!args) SWIG_fail;
33004 swig_obj[0] = args;
33005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33006 if (!SWIG_IsOK(res1)) {
33007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33008 }
33009 arg1 = reinterpret_cast< wxWindow * >(argp1);
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = (bool)(arg1)->Destroy();
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 {
33017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33018 }
33019 return resultobj;
33020 fail:
33021 return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33026 PyObject *resultobj = 0;
33027 wxWindow *arg1 = (wxWindow *) 0 ;
33028 bool result;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 PyObject *swig_obj[1] ;
33032
33033 if (!args) SWIG_fail;
33034 swig_obj[0] = args;
33035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33036 if (!SWIG_IsOK(res1)) {
33037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33038 }
33039 arg1 = reinterpret_cast< wxWindow * >(argp1);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 result = (bool)(arg1)->DestroyChildren();
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 {
33047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33048 }
33049 return resultobj;
33050 fail:
33051 return NULL;
33052 }
33053
33054
33055 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33056 PyObject *resultobj = 0;
33057 wxWindow *arg1 = (wxWindow *) 0 ;
33058 bool result;
33059 void *argp1 = 0 ;
33060 int res1 = 0 ;
33061 PyObject *swig_obj[1] ;
33062
33063 if (!args) SWIG_fail;
33064 swig_obj[0] = args;
33065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33066 if (!SWIG_IsOK(res1)) {
33067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33068 }
33069 arg1 = reinterpret_cast< wxWindow * >(argp1);
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33073 wxPyEndAllowThreads(__tstate);
33074 if (PyErr_Occurred()) SWIG_fail;
33075 }
33076 {
33077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33078 }
33079 return resultobj;
33080 fail:
33081 return NULL;
33082 }
33083
33084
33085 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33086 PyObject *resultobj = 0;
33087 wxWindow *arg1 = (wxWindow *) 0 ;
33088 wxString *arg2 = 0 ;
33089 void *argp1 = 0 ;
33090 int res1 = 0 ;
33091 bool temp2 = false ;
33092 PyObject * obj0 = 0 ;
33093 PyObject * obj1 = 0 ;
33094 char * kwnames[] = {
33095 (char *) "self",(char *) "label", NULL
33096 };
33097
33098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33100 if (!SWIG_IsOK(res1)) {
33101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33102 }
33103 arg1 = reinterpret_cast< wxWindow * >(argp1);
33104 {
33105 arg2 = wxString_in_helper(obj1);
33106 if (arg2 == NULL) SWIG_fail;
33107 temp2 = true;
33108 }
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 (arg1)->SetLabel((wxString const &)*arg2);
33112 wxPyEndAllowThreads(__tstate);
33113 if (PyErr_Occurred()) SWIG_fail;
33114 }
33115 resultobj = SWIG_Py_Void();
33116 {
33117 if (temp2)
33118 delete arg2;
33119 }
33120 return resultobj;
33121 fail:
33122 {
33123 if (temp2)
33124 delete arg2;
33125 }
33126 return NULL;
33127 }
33128
33129
33130 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33131 PyObject *resultobj = 0;
33132 wxWindow *arg1 = (wxWindow *) 0 ;
33133 wxString result;
33134 void *argp1 = 0 ;
33135 int res1 = 0 ;
33136 PyObject *swig_obj[1] ;
33137
33138 if (!args) SWIG_fail;
33139 swig_obj[0] = args;
33140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = ((wxWindow const *)arg1)->GetLabel();
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 {
33152 #if wxUSE_UNICODE
33153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33154 #else
33155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33156 #endif
33157 }
33158 return resultobj;
33159 fail:
33160 return NULL;
33161 }
33162
33163
33164 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj = 0;
33166 wxWindow *arg1 = (wxWindow *) 0 ;
33167 wxString *arg2 = 0 ;
33168 void *argp1 = 0 ;
33169 int res1 = 0 ;
33170 bool temp2 = false ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char * kwnames[] = {
33174 (char *) "self",(char *) "name", NULL
33175 };
33176
33177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 {
33184 arg2 = wxString_in_helper(obj1);
33185 if (arg2 == NULL) SWIG_fail;
33186 temp2 = true;
33187 }
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->SetName((wxString const &)*arg2);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 {
33196 if (temp2)
33197 delete arg2;
33198 }
33199 return resultobj;
33200 fail:
33201 {
33202 if (temp2)
33203 delete arg2;
33204 }
33205 return NULL;
33206 }
33207
33208
33209 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33210 PyObject *resultobj = 0;
33211 wxWindow *arg1 = (wxWindow *) 0 ;
33212 wxString result;
33213 void *argp1 = 0 ;
33214 int res1 = 0 ;
33215 PyObject *swig_obj[1] ;
33216
33217 if (!args) SWIG_fail;
33218 swig_obj[0] = args;
33219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33220 if (!SWIG_IsOK(res1)) {
33221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33222 }
33223 arg1 = reinterpret_cast< wxWindow * >(argp1);
33224 {
33225 PyThreadState* __tstate = wxPyBeginAllowThreads();
33226 result = ((wxWindow const *)arg1)->GetName();
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 #if wxUSE_UNICODE
33232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33233 #else
33234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33235 #endif
33236 }
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 wxWindowVariant arg2 ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 int val2 ;
33250 int ecode2 = 0 ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "variant", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33261 }
33262 arg1 = reinterpret_cast< wxWindow * >(argp1);
33263 ecode2 = SWIG_AsVal_int(obj1, &val2);
33264 if (!SWIG_IsOK(ecode2)) {
33265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33266 }
33267 arg2 = static_cast< wxWindowVariant >(val2);
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 (arg1)->SetWindowVariant(arg2);
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 resultobj = SWIG_Py_Void();
33275 return resultobj;
33276 fail:
33277 return NULL;
33278 }
33279
33280
33281 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33282 PyObject *resultobj = 0;
33283 wxWindow *arg1 = (wxWindow *) 0 ;
33284 wxWindowVariant result;
33285 void *argp1 = 0 ;
33286 int res1 = 0 ;
33287 PyObject *swig_obj[1] ;
33288
33289 if (!args) SWIG_fail;
33290 swig_obj[0] = args;
33291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33292 if (!SWIG_IsOK(res1)) {
33293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33294 }
33295 arg1 = reinterpret_cast< wxWindow * >(argp1);
33296 {
33297 PyThreadState* __tstate = wxPyBeginAllowThreads();
33298 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33299 wxPyEndAllowThreads(__tstate);
33300 if (PyErr_Occurred()) SWIG_fail;
33301 }
33302 resultobj = SWIG_From_int(static_cast< int >(result));
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33310 PyObject *resultobj = 0;
33311 wxWindow *arg1 = (wxWindow *) 0 ;
33312 int arg2 ;
33313 void *argp1 = 0 ;
33314 int res1 = 0 ;
33315 int val2 ;
33316 int ecode2 = 0 ;
33317 PyObject * obj0 = 0 ;
33318 PyObject * obj1 = 0 ;
33319 char * kwnames[] = {
33320 (char *) "self",(char *) "winid", NULL
33321 };
33322
33323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33325 if (!SWIG_IsOK(res1)) {
33326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33327 }
33328 arg1 = reinterpret_cast< wxWindow * >(argp1);
33329 ecode2 = SWIG_AsVal_int(obj1, &val2);
33330 if (!SWIG_IsOK(ecode2)) {
33331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33332 }
33333 arg2 = static_cast< int >(val2);
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 (arg1)->SetId(arg2);
33337 wxPyEndAllowThreads(__tstate);
33338 if (PyErr_Occurred()) SWIG_fail;
33339 }
33340 resultobj = SWIG_Py_Void();
33341 return resultobj;
33342 fail:
33343 return NULL;
33344 }
33345
33346
33347 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33348 PyObject *resultobj = 0;
33349 wxWindow *arg1 = (wxWindow *) 0 ;
33350 int result;
33351 void *argp1 = 0 ;
33352 int res1 = 0 ;
33353 PyObject *swig_obj[1] ;
33354
33355 if (!args) SWIG_fail;
33356 swig_obj[0] = args;
33357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 {
33363 PyThreadState* __tstate = wxPyBeginAllowThreads();
33364 result = (int)((wxWindow const *)arg1)->GetId();
33365 wxPyEndAllowThreads(__tstate);
33366 if (PyErr_Occurred()) SWIG_fail;
33367 }
33368 resultobj = SWIG_From_int(static_cast< int >(result));
33369 return resultobj;
33370 fail:
33371 return NULL;
33372 }
33373
33374
33375 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33376 PyObject *resultobj = 0;
33377 int result;
33378
33379 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (int)wxWindow::NewControlId();
33383 wxPyEndAllowThreads(__tstate);
33384 if (PyErr_Occurred()) SWIG_fail;
33385 }
33386 resultobj = SWIG_From_int(static_cast< int >(result));
33387 return resultobj;
33388 fail:
33389 return NULL;
33390 }
33391
33392
33393 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33394 PyObject *resultobj = 0;
33395 int arg1 ;
33396 int result;
33397 int val1 ;
33398 int ecode1 = 0 ;
33399 PyObject * obj0 = 0 ;
33400 char * kwnames[] = {
33401 (char *) "winid", NULL
33402 };
33403
33404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33405 ecode1 = SWIG_AsVal_int(obj0, &val1);
33406 if (!SWIG_IsOK(ecode1)) {
33407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33408 }
33409 arg1 = static_cast< int >(val1);
33410 {
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (int)wxWindow::NextControlId(arg1);
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 resultobj = SWIG_From_int(static_cast< int >(result));
33417 return resultobj;
33418 fail:
33419 return NULL;
33420 }
33421
33422
33423 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33424 PyObject *resultobj = 0;
33425 int arg1 ;
33426 int result;
33427 int val1 ;
33428 int ecode1 = 0 ;
33429 PyObject * obj0 = 0 ;
33430 char * kwnames[] = {
33431 (char *) "winid", NULL
33432 };
33433
33434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33435 ecode1 = SWIG_AsVal_int(obj0, &val1);
33436 if (!SWIG_IsOK(ecode1)) {
33437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33438 }
33439 arg1 = static_cast< int >(val1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (int)wxWindow::PrevControlId(arg1);
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 resultobj = SWIG_From_int(static_cast< int >(result));
33447 return resultobj;
33448 fail:
33449 return NULL;
33450 }
33451
33452
33453 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33454 PyObject *resultobj = 0;
33455 wxWindow *arg1 = (wxWindow *) 0 ;
33456 wxLayoutDirection result;
33457 void *argp1 = 0 ;
33458 int res1 = 0 ;
33459 PyObject *swig_obj[1] ;
33460
33461 if (!args) SWIG_fail;
33462 swig_obj[0] = args;
33463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33464 if (!SWIG_IsOK(res1)) {
33465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33466 }
33467 arg1 = reinterpret_cast< wxWindow * >(argp1);
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 resultobj = SWIG_From_int(static_cast< int >(result));
33475 return resultobj;
33476 fail:
33477 return NULL;
33478 }
33479
33480
33481 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj = 0;
33483 wxWindow *arg1 = (wxWindow *) 0 ;
33484 wxLayoutDirection arg2 ;
33485 void *argp1 = 0 ;
33486 int res1 = 0 ;
33487 int val2 ;
33488 int ecode2 = 0 ;
33489 PyObject * obj0 = 0 ;
33490 PyObject * obj1 = 0 ;
33491 char * kwnames[] = {
33492 (char *) "self",(char *) "dir", NULL
33493 };
33494
33495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33497 if (!SWIG_IsOK(res1)) {
33498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33499 }
33500 arg1 = reinterpret_cast< wxWindow * >(argp1);
33501 ecode2 = SWIG_AsVal_int(obj1, &val2);
33502 if (!SWIG_IsOK(ecode2)) {
33503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33504 }
33505 arg2 = static_cast< wxLayoutDirection >(val2);
33506 {
33507 PyThreadState* __tstate = wxPyBeginAllowThreads();
33508 (arg1)->SetLayoutDirection(arg2);
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 resultobj = SWIG_Py_Void();
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj = 0;
33521 wxWindow *arg1 = (wxWindow *) 0 ;
33522 int arg2 ;
33523 int arg3 ;
33524 int arg4 ;
33525 int result;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 int val2 ;
33529 int ecode2 = 0 ;
33530 int val3 ;
33531 int ecode3 = 0 ;
33532 int val4 ;
33533 int ecode4 = 0 ;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 PyObject * obj2 = 0 ;
33537 PyObject * obj3 = 0 ;
33538 char * kwnames[] = {
33539 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33540 };
33541
33542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33544 if (!SWIG_IsOK(res1)) {
33545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33546 }
33547 arg1 = reinterpret_cast< wxWindow * >(argp1);
33548 ecode2 = SWIG_AsVal_int(obj1, &val2);
33549 if (!SWIG_IsOK(ecode2)) {
33550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33551 }
33552 arg2 = static_cast< int >(val2);
33553 ecode3 = SWIG_AsVal_int(obj2, &val3);
33554 if (!SWIG_IsOK(ecode3)) {
33555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33556 }
33557 arg3 = static_cast< int >(val3);
33558 ecode4 = SWIG_AsVal_int(obj3, &val4);
33559 if (!SWIG_IsOK(ecode4)) {
33560 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33561 }
33562 arg4 = static_cast< int >(val4);
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33566 wxPyEndAllowThreads(__tstate);
33567 if (PyErr_Occurred()) SWIG_fail;
33568 }
33569 resultobj = SWIG_From_int(static_cast< int >(result));
33570 return resultobj;
33571 fail:
33572 return NULL;
33573 }
33574
33575
33576 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33577 PyObject *resultobj = 0;
33578 wxWindow *arg1 = (wxWindow *) 0 ;
33579 wxSize *arg2 = 0 ;
33580 void *argp1 = 0 ;
33581 int res1 = 0 ;
33582 wxSize temp2 ;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 char * kwnames[] = {
33586 (char *) "self",(char *) "size", NULL
33587 };
33588
33589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 {
33596 arg2 = &temp2;
33597 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33598 }
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 (arg1)->SetSize((wxSize const &)*arg2);
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 resultobj = SWIG_Py_Void();
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj = 0;
33614 wxWindow *arg1 = (wxWindow *) 0 ;
33615 int arg2 ;
33616 int arg3 ;
33617 int arg4 ;
33618 int arg5 ;
33619 int arg6 = (int) wxSIZE_AUTO ;
33620 void *argp1 = 0 ;
33621 int res1 = 0 ;
33622 int val2 ;
33623 int ecode2 = 0 ;
33624 int val3 ;
33625 int ecode3 = 0 ;
33626 int val4 ;
33627 int ecode4 = 0 ;
33628 int val5 ;
33629 int ecode5 = 0 ;
33630 int val6 ;
33631 int ecode6 = 0 ;
33632 PyObject * obj0 = 0 ;
33633 PyObject * obj1 = 0 ;
33634 PyObject * obj2 = 0 ;
33635 PyObject * obj3 = 0 ;
33636 PyObject * obj4 = 0 ;
33637 PyObject * obj5 = 0 ;
33638 char * kwnames[] = {
33639 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33640 };
33641
33642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33644 if (!SWIG_IsOK(res1)) {
33645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33646 }
33647 arg1 = reinterpret_cast< wxWindow * >(argp1);
33648 ecode2 = SWIG_AsVal_int(obj1, &val2);
33649 if (!SWIG_IsOK(ecode2)) {
33650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33651 }
33652 arg2 = static_cast< int >(val2);
33653 ecode3 = SWIG_AsVal_int(obj2, &val3);
33654 if (!SWIG_IsOK(ecode3)) {
33655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33656 }
33657 arg3 = static_cast< int >(val3);
33658 ecode4 = SWIG_AsVal_int(obj3, &val4);
33659 if (!SWIG_IsOK(ecode4)) {
33660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33661 }
33662 arg4 = static_cast< int >(val4);
33663 ecode5 = SWIG_AsVal_int(obj4, &val5);
33664 if (!SWIG_IsOK(ecode5)) {
33665 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33666 }
33667 arg5 = static_cast< int >(val5);
33668 if (obj5) {
33669 ecode6 = SWIG_AsVal_int(obj5, &val6);
33670 if (!SWIG_IsOK(ecode6)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33672 }
33673 arg6 = static_cast< int >(val6);
33674 }
33675 {
33676 PyThreadState* __tstate = wxPyBeginAllowThreads();
33677 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 resultobj = SWIG_Py_Void();
33682 return resultobj;
33683 fail:
33684 return NULL;
33685 }
33686
33687
33688 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33689 PyObject *resultobj = 0;
33690 wxWindow *arg1 = (wxWindow *) 0 ;
33691 wxRect *arg2 = 0 ;
33692 int arg3 = (int) wxSIZE_AUTO ;
33693 void *argp1 = 0 ;
33694 int res1 = 0 ;
33695 wxRect temp2 ;
33696 int val3 ;
33697 int ecode3 = 0 ;
33698 PyObject * obj0 = 0 ;
33699 PyObject * obj1 = 0 ;
33700 PyObject * obj2 = 0 ;
33701 char * kwnames[] = {
33702 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33703 };
33704
33705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33707 if (!SWIG_IsOK(res1)) {
33708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33709 }
33710 arg1 = reinterpret_cast< wxWindow * >(argp1);
33711 {
33712 arg2 = &temp2;
33713 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33714 }
33715 if (obj2) {
33716 ecode3 = SWIG_AsVal_int(obj2, &val3);
33717 if (!SWIG_IsOK(ecode3)) {
33718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33719 }
33720 arg3 = static_cast< int >(val3);
33721 }
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 resultobj = SWIG_Py_Void();
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 int arg2 ;
33739 int arg3 ;
33740 void *argp1 = 0 ;
33741 int res1 = 0 ;
33742 int val2 ;
33743 int ecode2 = 0 ;
33744 int val3 ;
33745 int ecode3 = 0 ;
33746 PyObject * obj0 = 0 ;
33747 PyObject * obj1 = 0 ;
33748 PyObject * obj2 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "width",(char *) "height", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_int(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33762 }
33763 arg2 = static_cast< int >(val2);
33764 ecode3 = SWIG_AsVal_int(obj2, &val3);
33765 if (!SWIG_IsOK(ecode3)) {
33766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33767 }
33768 arg3 = static_cast< int >(val3);
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 (arg1)->SetSize(arg2,arg3);
33772 wxPyEndAllowThreads(__tstate);
33773 if (PyErr_Occurred()) SWIG_fail;
33774 }
33775 resultobj = SWIG_Py_Void();
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33783 PyObject *resultobj = 0;
33784 wxWindow *arg1 = (wxWindow *) 0 ;
33785 wxPoint *arg2 = 0 ;
33786 int arg3 = (int) wxSIZE_USE_EXISTING ;
33787 void *argp1 = 0 ;
33788 int res1 = 0 ;
33789 wxPoint temp2 ;
33790 int val3 ;
33791 int ecode3 = 0 ;
33792 PyObject * obj0 = 0 ;
33793 PyObject * obj1 = 0 ;
33794 PyObject * obj2 = 0 ;
33795 char * kwnames[] = {
33796 (char *) "self",(char *) "pt",(char *) "flags", NULL
33797 };
33798
33799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33801 if (!SWIG_IsOK(res1)) {
33802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33803 }
33804 arg1 = reinterpret_cast< wxWindow * >(argp1);
33805 {
33806 arg2 = &temp2;
33807 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33808 }
33809 if (obj2) {
33810 ecode3 = SWIG_AsVal_int(obj2, &val3);
33811 if (!SWIG_IsOK(ecode3)) {
33812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33813 }
33814 arg3 = static_cast< int >(val3);
33815 }
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 (arg1)->Move((wxPoint const &)*arg2,arg3);
33819 wxPyEndAllowThreads(__tstate);
33820 if (PyErr_Occurred()) SWIG_fail;
33821 }
33822 resultobj = SWIG_Py_Void();
33823 return resultobj;
33824 fail:
33825 return NULL;
33826 }
33827
33828
33829 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33830 PyObject *resultobj = 0;
33831 wxWindow *arg1 = (wxWindow *) 0 ;
33832 int arg2 ;
33833 int arg3 ;
33834 int arg4 = (int) wxSIZE_USE_EXISTING ;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 int val2 ;
33838 int ecode2 = 0 ;
33839 int val3 ;
33840 int ecode3 = 0 ;
33841 int val4 ;
33842 int ecode4 = 0 ;
33843 PyObject * obj0 = 0 ;
33844 PyObject * obj1 = 0 ;
33845 PyObject * obj2 = 0 ;
33846 PyObject * obj3 = 0 ;
33847 char * kwnames[] = {
33848 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33849 };
33850
33851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33853 if (!SWIG_IsOK(res1)) {
33854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33855 }
33856 arg1 = reinterpret_cast< wxWindow * >(argp1);
33857 ecode2 = SWIG_AsVal_int(obj1, &val2);
33858 if (!SWIG_IsOK(ecode2)) {
33859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33860 }
33861 arg2 = static_cast< int >(val2);
33862 ecode3 = SWIG_AsVal_int(obj2, &val3);
33863 if (!SWIG_IsOK(ecode3)) {
33864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33865 }
33866 arg3 = static_cast< int >(val3);
33867 if (obj3) {
33868 ecode4 = SWIG_AsVal_int(obj3, &val4);
33869 if (!SWIG_IsOK(ecode4)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33871 }
33872 arg4 = static_cast< int >(val4);
33873 }
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 (arg1)->Move(arg2,arg3,arg4);
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 resultobj = SWIG_Py_Void();
33881 return resultobj;
33882 fail:
33883 return NULL;
33884 }
33885
33886
33887 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33888 PyObject *resultobj = 0;
33889 wxWindow *arg1 = (wxWindow *) 0 ;
33890 wxSize const &arg2_defvalue = wxDefaultSize ;
33891 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33892 void *argp1 = 0 ;
33893 int res1 = 0 ;
33894 wxSize temp2 ;
33895 PyObject * obj0 = 0 ;
33896 PyObject * obj1 = 0 ;
33897 char * kwnames[] = {
33898 (char *) "self",(char *) "size", NULL
33899 };
33900
33901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
33902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33905 }
33906 arg1 = reinterpret_cast< wxWindow * >(argp1);
33907 if (obj1) {
33908 {
33909 arg2 = &temp2;
33910 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33911 }
33912 }
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 resultobj = SWIG_Py_Void();
33920 return resultobj;
33921 fail:
33922 return NULL;
33923 }
33924
33925
33926 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33927 PyObject *resultobj = 0;
33928 wxWindow *arg1 = (wxWindow *) 0 ;
33929 void *argp1 = 0 ;
33930 int res1 = 0 ;
33931 PyObject *swig_obj[1] ;
33932
33933 if (!args) SWIG_fail;
33934 swig_obj[0] = args;
33935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33936 if (!SWIG_IsOK(res1)) {
33937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33938 }
33939 arg1 = reinterpret_cast< wxWindow * >(argp1);
33940 {
33941 PyThreadState* __tstate = wxPyBeginAllowThreads();
33942 (arg1)->Raise();
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 resultobj = SWIG_Py_Void();
33947 return resultobj;
33948 fail:
33949 return NULL;
33950 }
33951
33952
33953 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33954 PyObject *resultobj = 0;
33955 wxWindow *arg1 = (wxWindow *) 0 ;
33956 void *argp1 = 0 ;
33957 int res1 = 0 ;
33958 PyObject *swig_obj[1] ;
33959
33960 if (!args) SWIG_fail;
33961 swig_obj[0] = args;
33962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33963 if (!SWIG_IsOK(res1)) {
33964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33965 }
33966 arg1 = reinterpret_cast< wxWindow * >(argp1);
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 (arg1)->Lower();
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 resultobj = SWIG_Py_Void();
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj = 0;
33982 wxWindow *arg1 = (wxWindow *) 0 ;
33983 wxSize *arg2 = 0 ;
33984 void *argp1 = 0 ;
33985 int res1 = 0 ;
33986 wxSize temp2 ;
33987 PyObject * obj0 = 0 ;
33988 PyObject * obj1 = 0 ;
33989 char * kwnames[] = {
33990 (char *) "self",(char *) "size", NULL
33991 };
33992
33993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33995 if (!SWIG_IsOK(res1)) {
33996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33997 }
33998 arg1 = reinterpret_cast< wxWindow * >(argp1);
33999 {
34000 arg2 = &temp2;
34001 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34002 }
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 (arg1)->SetClientSize((wxSize const &)*arg2);
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 resultobj = SWIG_Py_Void();
34010 return resultobj;
34011 fail:
34012 return NULL;
34013 }
34014
34015
34016 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34017 PyObject *resultobj = 0;
34018 wxWindow *arg1 = (wxWindow *) 0 ;
34019 int arg2 ;
34020 int arg3 ;
34021 void *argp1 = 0 ;
34022 int res1 = 0 ;
34023 int val2 ;
34024 int ecode2 = 0 ;
34025 int val3 ;
34026 int ecode3 = 0 ;
34027 PyObject * obj0 = 0 ;
34028 PyObject * obj1 = 0 ;
34029 PyObject * obj2 = 0 ;
34030 char * kwnames[] = {
34031 (char *) "self",(char *) "width",(char *) "height", NULL
34032 };
34033
34034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34036 if (!SWIG_IsOK(res1)) {
34037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34038 }
34039 arg1 = reinterpret_cast< wxWindow * >(argp1);
34040 ecode2 = SWIG_AsVal_int(obj1, &val2);
34041 if (!SWIG_IsOK(ecode2)) {
34042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34043 }
34044 arg2 = static_cast< int >(val2);
34045 ecode3 = SWIG_AsVal_int(obj2, &val3);
34046 if (!SWIG_IsOK(ecode3)) {
34047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34048 }
34049 arg3 = static_cast< int >(val3);
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 (arg1)->SetClientSize(arg2,arg3);
34053 wxPyEndAllowThreads(__tstate);
34054 if (PyErr_Occurred()) SWIG_fail;
34055 }
34056 resultobj = SWIG_Py_Void();
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 wxRect *arg2 = 0 ;
34067 void *argp1 = 0 ;
34068 int res1 = 0 ;
34069 wxRect temp2 ;
34070 PyObject * obj0 = 0 ;
34071 PyObject * obj1 = 0 ;
34072 char * kwnames[] = {
34073 (char *) "self",(char *) "rect", NULL
34074 };
34075
34076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34080 }
34081 arg1 = reinterpret_cast< wxWindow * >(argp1);
34082 {
34083 arg2 = &temp2;
34084 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34085 }
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 (arg1)->SetClientSize((wxRect const &)*arg2);
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 resultobj = SWIG_Py_Void();
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34100 PyObject *resultobj = 0;
34101 wxWindow *arg1 = (wxWindow *) 0 ;
34102 wxPoint result;
34103 void *argp1 = 0 ;
34104 int res1 = 0 ;
34105 PyObject *swig_obj[1] ;
34106
34107 if (!args) SWIG_fail;
34108 swig_obj[0] = args;
34109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34110 if (!SWIG_IsOK(res1)) {
34111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34112 }
34113 arg1 = reinterpret_cast< wxWindow * >(argp1);
34114 {
34115 PyThreadState* __tstate = wxPyBeginAllowThreads();
34116 result = ((wxWindow const *)arg1)->GetPosition();
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34128 PyObject *resultobj = 0;
34129 wxWindow *arg1 = (wxWindow *) 0 ;
34130 int *arg2 = (int *) 0 ;
34131 int *arg3 = (int *) 0 ;
34132 void *argp1 = 0 ;
34133 int res1 = 0 ;
34134 int temp2 ;
34135 int res2 = SWIG_TMPOBJ ;
34136 int temp3 ;
34137 int res3 = SWIG_TMPOBJ ;
34138 PyObject *swig_obj[1] ;
34139
34140 arg2 = &temp2;
34141 arg3 = &temp3;
34142 if (!args) SWIG_fail;
34143 swig_obj[0] = args;
34144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34147 }
34148 arg1 = reinterpret_cast< wxWindow * >(argp1);
34149 {
34150 PyThreadState* __tstate = wxPyBeginAllowThreads();
34151 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 resultobj = SWIG_Py_Void();
34156 if (SWIG_IsTmpObj(res2)) {
34157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34158 } else {
34159 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34161 }
34162 if (SWIG_IsTmpObj(res3)) {
34163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34164 } else {
34165 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34167 }
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34175 PyObject *resultobj = 0;
34176 wxWindow *arg1 = (wxWindow *) 0 ;
34177 wxPoint result;
34178 void *argp1 = 0 ;
34179 int res1 = 0 ;
34180 PyObject *swig_obj[1] ;
34181
34182 if (!args) SWIG_fail;
34183 swig_obj[0] = args;
34184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34185 if (!SWIG_IsOK(res1)) {
34186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34187 }
34188 arg1 = reinterpret_cast< wxWindow * >(argp1);
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = ((wxWindow const *)arg1)->GetScreenPosition();
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34196 return resultobj;
34197 fail:
34198 return NULL;
34199 }
34200
34201
34202 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34203 PyObject *resultobj = 0;
34204 wxWindow *arg1 = (wxWindow *) 0 ;
34205 int *arg2 = (int *) 0 ;
34206 int *arg3 = (int *) 0 ;
34207 void *argp1 = 0 ;
34208 int res1 = 0 ;
34209 int temp2 ;
34210 int res2 = SWIG_TMPOBJ ;
34211 int temp3 ;
34212 int res3 = SWIG_TMPOBJ ;
34213 PyObject *swig_obj[1] ;
34214
34215 arg2 = &temp2;
34216 arg3 = &temp3;
34217 if (!args) SWIG_fail;
34218 swig_obj[0] = args;
34219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34222 }
34223 arg1 = reinterpret_cast< wxWindow * >(argp1);
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 resultobj = SWIG_Py_Void();
34231 if (SWIG_IsTmpObj(res2)) {
34232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34233 } else {
34234 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34236 }
34237 if (SWIG_IsTmpObj(res3)) {
34238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34239 } else {
34240 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34242 }
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 wxRect result;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 PyObject *swig_obj[1] ;
34256
34257 if (!args) SWIG_fail;
34258 swig_obj[0] = args;
34259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34260 if (!SWIG_IsOK(res1)) {
34261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34262 }
34263 arg1 = reinterpret_cast< wxWindow * >(argp1);
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = ((wxWindow const *)arg1)->GetScreenRect();
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34278 PyObject *resultobj = 0;
34279 wxWindow *arg1 = (wxWindow *) 0 ;
34280 wxSize result;
34281 void *argp1 = 0 ;
34282 int res1 = 0 ;
34283 PyObject *swig_obj[1] ;
34284
34285 if (!args) SWIG_fail;
34286 swig_obj[0] = args;
34287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34288 if (!SWIG_IsOK(res1)) {
34289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34290 }
34291 arg1 = reinterpret_cast< wxWindow * >(argp1);
34292 {
34293 PyThreadState* __tstate = wxPyBeginAllowThreads();
34294 result = ((wxWindow const *)arg1)->GetSize();
34295 wxPyEndAllowThreads(__tstate);
34296 if (PyErr_Occurred()) SWIG_fail;
34297 }
34298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34299 return resultobj;
34300 fail:
34301 return NULL;
34302 }
34303
34304
34305 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34306 PyObject *resultobj = 0;
34307 wxWindow *arg1 = (wxWindow *) 0 ;
34308 int *arg2 = (int *) 0 ;
34309 int *arg3 = (int *) 0 ;
34310 void *argp1 = 0 ;
34311 int res1 = 0 ;
34312 int temp2 ;
34313 int res2 = SWIG_TMPOBJ ;
34314 int temp3 ;
34315 int res3 = SWIG_TMPOBJ ;
34316 PyObject *swig_obj[1] ;
34317
34318 arg2 = &temp2;
34319 arg3 = &temp3;
34320 if (!args) SWIG_fail;
34321 swig_obj[0] = args;
34322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34323 if (!SWIG_IsOK(res1)) {
34324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34325 }
34326 arg1 = reinterpret_cast< wxWindow * >(argp1);
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 resultobj = SWIG_Py_Void();
34334 if (SWIG_IsTmpObj(res2)) {
34335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34336 } else {
34337 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34339 }
34340 if (SWIG_IsTmpObj(res3)) {
34341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34342 } else {
34343 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34345 }
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34353 PyObject *resultobj = 0;
34354 wxWindow *arg1 = (wxWindow *) 0 ;
34355 wxRect result;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 PyObject *swig_obj[1] ;
34359
34360 if (!args) SWIG_fail;
34361 swig_obj[0] = args;
34362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34363 if (!SWIG_IsOK(res1)) {
34364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34365 }
34366 arg1 = reinterpret_cast< wxWindow * >(argp1);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 result = ((wxWindow const *)arg1)->GetRect();
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 wxSize result;
34384 void *argp1 = 0 ;
34385 int res1 = 0 ;
34386 PyObject *swig_obj[1] ;
34387
34388 if (!args) SWIG_fail;
34389 swig_obj[0] = args;
34390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34391 if (!SWIG_IsOK(res1)) {
34392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34393 }
34394 arg1 = reinterpret_cast< wxWindow * >(argp1);
34395 {
34396 PyThreadState* __tstate = wxPyBeginAllowThreads();
34397 result = ((wxWindow const *)arg1)->GetClientSize();
34398 wxPyEndAllowThreads(__tstate);
34399 if (PyErr_Occurred()) SWIG_fail;
34400 }
34401 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34402 return resultobj;
34403 fail:
34404 return NULL;
34405 }
34406
34407
34408 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34409 PyObject *resultobj = 0;
34410 wxWindow *arg1 = (wxWindow *) 0 ;
34411 int *arg2 = (int *) 0 ;
34412 int *arg3 = (int *) 0 ;
34413 void *argp1 = 0 ;
34414 int res1 = 0 ;
34415 int temp2 ;
34416 int res2 = SWIG_TMPOBJ ;
34417 int temp3 ;
34418 int res3 = SWIG_TMPOBJ ;
34419 PyObject *swig_obj[1] ;
34420
34421 arg2 = &temp2;
34422 arg3 = &temp3;
34423 if (!args) SWIG_fail;
34424 swig_obj[0] = args;
34425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34428 }
34429 arg1 = reinterpret_cast< wxWindow * >(argp1);
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34433 wxPyEndAllowThreads(__tstate);
34434 if (PyErr_Occurred()) SWIG_fail;
34435 }
34436 resultobj = SWIG_Py_Void();
34437 if (SWIG_IsTmpObj(res2)) {
34438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34439 } else {
34440 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34442 }
34443 if (SWIG_IsTmpObj(res3)) {
34444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34445 } else {
34446 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34448 }
34449 return resultobj;
34450 fail:
34451 return NULL;
34452 }
34453
34454
34455 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34456 PyObject *resultobj = 0;
34457 wxWindow *arg1 = (wxWindow *) 0 ;
34458 wxPoint result;
34459 void *argp1 = 0 ;
34460 int res1 = 0 ;
34461 PyObject *swig_obj[1] ;
34462
34463 if (!args) SWIG_fail;
34464 swig_obj[0] = args;
34465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34466 if (!SWIG_IsOK(res1)) {
34467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34468 }
34469 arg1 = reinterpret_cast< wxWindow * >(argp1);
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 wxRect result;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 PyObject *swig_obj[1] ;
34490
34491 if (!args) SWIG_fail;
34492 swig_obj[0] = args;
34493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34496 }
34497 arg1 = reinterpret_cast< wxWindow * >(argp1);
34498 {
34499 PyThreadState* __tstate = wxPyBeginAllowThreads();
34500 result = ((wxWindow const *)arg1)->GetClientRect();
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34512 PyObject *resultobj = 0;
34513 wxWindow *arg1 = (wxWindow *) 0 ;
34514 wxSize result;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 PyObject *swig_obj[1] ;
34518
34519 if (!args) SWIG_fail;
34520 swig_obj[0] = args;
34521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 result = ((wxWindow const *)arg1)->GetBestSize();
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34540 PyObject *resultobj = 0;
34541 wxWindow *arg1 = (wxWindow *) 0 ;
34542 int *arg2 = (int *) 0 ;
34543 int *arg3 = (int *) 0 ;
34544 void *argp1 = 0 ;
34545 int res1 = 0 ;
34546 int temp2 ;
34547 int res2 = SWIG_TMPOBJ ;
34548 int temp3 ;
34549 int res3 = SWIG_TMPOBJ ;
34550 PyObject *swig_obj[1] ;
34551
34552 arg2 = &temp2;
34553 arg3 = &temp3;
34554 if (!args) SWIG_fail;
34555 swig_obj[0] = args;
34556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34559 }
34560 arg1 = reinterpret_cast< wxWindow * >(argp1);
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 resultobj = SWIG_Py_Void();
34568 if (SWIG_IsTmpObj(res2)) {
34569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34570 } else {
34571 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34573 }
34574 if (SWIG_IsTmpObj(res3)) {
34575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34576 } else {
34577 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34579 }
34580 return resultobj;
34581 fail:
34582 return NULL;
34583 }
34584
34585
34586 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34587 PyObject *resultobj = 0;
34588 wxWindow *arg1 = (wxWindow *) 0 ;
34589 void *argp1 = 0 ;
34590 int res1 = 0 ;
34591 PyObject *swig_obj[1] ;
34592
34593 if (!args) SWIG_fail;
34594 swig_obj[0] = args;
34595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34596 if (!SWIG_IsOK(res1)) {
34597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34598 }
34599 arg1 = reinterpret_cast< wxWindow * >(argp1);
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 (arg1)->InvalidateBestSize();
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 resultobj = SWIG_Py_Void();
34607 return resultobj;
34608 fail:
34609 return NULL;
34610 }
34611
34612
34613 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34614 PyObject *resultobj = 0;
34615 wxWindow *arg1 = (wxWindow *) 0 ;
34616 wxSize *arg2 = 0 ;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 wxSize temp2 ;
34620 PyObject * obj0 = 0 ;
34621 PyObject * obj1 = 0 ;
34622 char * kwnames[] = {
34623 (char *) "self",(char *) "size", NULL
34624 };
34625
34626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34628 if (!SWIG_IsOK(res1)) {
34629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34630 }
34631 arg1 = reinterpret_cast< wxWindow * >(argp1);
34632 {
34633 arg2 = &temp2;
34634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34635 }
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 resultobj = SWIG_Py_Void();
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34650 PyObject *resultobj = 0;
34651 wxWindow *arg1 = (wxWindow *) 0 ;
34652 wxSize result;
34653 void *argp1 = 0 ;
34654 int res1 = 0 ;
34655 PyObject *swig_obj[1] ;
34656
34657 if (!args) SWIG_fail;
34658 swig_obj[0] = args;
34659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34660 if (!SWIG_IsOK(res1)) {
34661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34662 }
34663 arg1 = reinterpret_cast< wxWindow * >(argp1);
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 result = ((wxWindow const *)arg1)->GetBestFittingSize();
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34678 PyObject *resultobj = 0;
34679 wxWindow *arg1 = (wxWindow *) 0 ;
34680 int arg2 = (int) wxBOTH ;
34681 void *argp1 = 0 ;
34682 int res1 = 0 ;
34683 int val2 ;
34684 int ecode2 = 0 ;
34685 PyObject * obj0 = 0 ;
34686 PyObject * obj1 = 0 ;
34687 char * kwnames[] = {
34688 (char *) "self",(char *) "direction", NULL
34689 };
34690
34691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34693 if (!SWIG_IsOK(res1)) {
34694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34695 }
34696 arg1 = reinterpret_cast< wxWindow * >(argp1);
34697 if (obj1) {
34698 ecode2 = SWIG_AsVal_int(obj1, &val2);
34699 if (!SWIG_IsOK(ecode2)) {
34700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34701 }
34702 arg2 = static_cast< int >(val2);
34703 }
34704 {
34705 PyThreadState* __tstate = wxPyBeginAllowThreads();
34706 (arg1)->Center(arg2);
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 resultobj = SWIG_Py_Void();
34711 return resultobj;
34712 fail:
34713 return NULL;
34714 }
34715
34716
34717 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34718 PyObject *resultobj = 0;
34719 wxWindow *arg1 = (wxWindow *) 0 ;
34720 int arg2 = (int) wxBOTH ;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 int val2 ;
34724 int ecode2 = 0 ;
34725 PyObject * obj0 = 0 ;
34726 PyObject * obj1 = 0 ;
34727 char * kwnames[] = {
34728 (char *) "self",(char *) "dir", NULL
34729 };
34730
34731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34735 }
34736 arg1 = reinterpret_cast< wxWindow * >(argp1);
34737 if (obj1) {
34738 ecode2 = SWIG_AsVal_int(obj1, &val2);
34739 if (!SWIG_IsOK(ecode2)) {
34740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34741 }
34742 arg2 = static_cast< int >(val2);
34743 }
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 (arg1)->CenterOnParent(arg2);
34747 wxPyEndAllowThreads(__tstate);
34748 if (PyErr_Occurred()) SWIG_fail;
34749 }
34750 resultobj = SWIG_Py_Void();
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34758 PyObject *resultobj = 0;
34759 wxWindow *arg1 = (wxWindow *) 0 ;
34760 void *argp1 = 0 ;
34761 int res1 = 0 ;
34762 PyObject *swig_obj[1] ;
34763
34764 if (!args) SWIG_fail;
34765 swig_obj[0] = args;
34766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 (arg1)->Fit();
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 resultobj = SWIG_Py_Void();
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 void *argp1 = 0 ;
34788 int res1 = 0 ;
34789 PyObject *swig_obj[1] ;
34790
34791 if (!args) SWIG_fail;
34792 swig_obj[0] = args;
34793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34794 if (!SWIG_IsOK(res1)) {
34795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34796 }
34797 arg1 = reinterpret_cast< wxWindow * >(argp1);
34798 {
34799 PyThreadState* __tstate = wxPyBeginAllowThreads();
34800 (arg1)->FitInside();
34801 wxPyEndAllowThreads(__tstate);
34802 if (PyErr_Occurred()) SWIG_fail;
34803 }
34804 resultobj = SWIG_Py_Void();
34805 return resultobj;
34806 fail:
34807 return NULL;
34808 }
34809
34810
34811 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34812 PyObject *resultobj = 0;
34813 wxWindow *arg1 = (wxWindow *) 0 ;
34814 int arg2 ;
34815 int arg3 ;
34816 int arg4 = (int) -1 ;
34817 int arg5 = (int) -1 ;
34818 int arg6 = (int) -1 ;
34819 int arg7 = (int) -1 ;
34820 void *argp1 = 0 ;
34821 int res1 = 0 ;
34822 int val2 ;
34823 int ecode2 = 0 ;
34824 int val3 ;
34825 int ecode3 = 0 ;
34826 int val4 ;
34827 int ecode4 = 0 ;
34828 int val5 ;
34829 int ecode5 = 0 ;
34830 int val6 ;
34831 int ecode6 = 0 ;
34832 int val7 ;
34833 int ecode7 = 0 ;
34834 PyObject * obj0 = 0 ;
34835 PyObject * obj1 = 0 ;
34836 PyObject * obj2 = 0 ;
34837 PyObject * obj3 = 0 ;
34838 PyObject * obj4 = 0 ;
34839 PyObject * obj5 = 0 ;
34840 PyObject * obj6 = 0 ;
34841 char * kwnames[] = {
34842 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34843 };
34844
34845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34849 }
34850 arg1 = reinterpret_cast< wxWindow * >(argp1);
34851 ecode2 = SWIG_AsVal_int(obj1, &val2);
34852 if (!SWIG_IsOK(ecode2)) {
34853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34854 }
34855 arg2 = static_cast< int >(val2);
34856 ecode3 = SWIG_AsVal_int(obj2, &val3);
34857 if (!SWIG_IsOK(ecode3)) {
34858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34859 }
34860 arg3 = static_cast< int >(val3);
34861 if (obj3) {
34862 ecode4 = SWIG_AsVal_int(obj3, &val4);
34863 if (!SWIG_IsOK(ecode4)) {
34864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34865 }
34866 arg4 = static_cast< int >(val4);
34867 }
34868 if (obj4) {
34869 ecode5 = SWIG_AsVal_int(obj4, &val5);
34870 if (!SWIG_IsOK(ecode5)) {
34871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34872 }
34873 arg5 = static_cast< int >(val5);
34874 }
34875 if (obj5) {
34876 ecode6 = SWIG_AsVal_int(obj5, &val6);
34877 if (!SWIG_IsOK(ecode6)) {
34878 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34879 }
34880 arg6 = static_cast< int >(val6);
34881 }
34882 if (obj6) {
34883 ecode7 = SWIG_AsVal_int(obj6, &val7);
34884 if (!SWIG_IsOK(ecode7)) {
34885 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34886 }
34887 arg7 = static_cast< int >(val7);
34888 }
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 resultobj = SWIG_Py_Void();
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj = 0;
34904 wxWindow *arg1 = (wxWindow *) 0 ;
34905 wxSize *arg2 = 0 ;
34906 wxSize const &arg3_defvalue = wxDefaultSize ;
34907 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34908 wxSize const &arg4_defvalue = wxDefaultSize ;
34909 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 wxSize temp2 ;
34913 wxSize temp3 ;
34914 wxSize temp4 ;
34915 PyObject * obj0 = 0 ;
34916 PyObject * obj1 = 0 ;
34917 PyObject * obj2 = 0 ;
34918 PyObject * obj3 = 0 ;
34919 char * kwnames[] = {
34920 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34921 };
34922
34923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34925 if (!SWIG_IsOK(res1)) {
34926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34927 }
34928 arg1 = reinterpret_cast< wxWindow * >(argp1);
34929 {
34930 arg2 = &temp2;
34931 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34932 }
34933 if (obj2) {
34934 {
34935 arg3 = &temp3;
34936 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34937 }
34938 }
34939 if (obj3) {
34940 {
34941 arg4 = &temp4;
34942 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34943 }
34944 }
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 resultobj = SWIG_Py_Void();
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34959 PyObject *resultobj = 0;
34960 wxWindow *arg1 = (wxWindow *) 0 ;
34961 int arg2 ;
34962 int arg3 ;
34963 int arg4 = (int) -1 ;
34964 int arg5 = (int) -1 ;
34965 void *argp1 = 0 ;
34966 int res1 = 0 ;
34967 int val2 ;
34968 int ecode2 = 0 ;
34969 int val3 ;
34970 int ecode3 = 0 ;
34971 int val4 ;
34972 int ecode4 = 0 ;
34973 int val5 ;
34974 int ecode5 = 0 ;
34975 PyObject * obj0 = 0 ;
34976 PyObject * obj1 = 0 ;
34977 PyObject * obj2 = 0 ;
34978 PyObject * obj3 = 0 ;
34979 PyObject * obj4 = 0 ;
34980 char * kwnames[] = {
34981 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34982 };
34983
34984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34986 if (!SWIG_IsOK(res1)) {
34987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34988 }
34989 arg1 = reinterpret_cast< wxWindow * >(argp1);
34990 ecode2 = SWIG_AsVal_int(obj1, &val2);
34991 if (!SWIG_IsOK(ecode2)) {
34992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34993 }
34994 arg2 = static_cast< int >(val2);
34995 ecode3 = SWIG_AsVal_int(obj2, &val3);
34996 if (!SWIG_IsOK(ecode3)) {
34997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34998 }
34999 arg3 = static_cast< int >(val3);
35000 if (obj3) {
35001 ecode4 = SWIG_AsVal_int(obj3, &val4);
35002 if (!SWIG_IsOK(ecode4)) {
35003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35004 }
35005 arg4 = static_cast< int >(val4);
35006 }
35007 if (obj4) {
35008 ecode5 = SWIG_AsVal_int(obj4, &val5);
35009 if (!SWIG_IsOK(ecode5)) {
35010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35011 }
35012 arg5 = static_cast< int >(val5);
35013 }
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 resultobj = SWIG_Py_Void();
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj = 0;
35029 wxWindow *arg1 = (wxWindow *) 0 ;
35030 wxSize *arg2 = 0 ;
35031 wxSize const &arg3_defvalue = wxDefaultSize ;
35032 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35033 void *argp1 = 0 ;
35034 int res1 = 0 ;
35035 wxSize temp2 ;
35036 wxSize temp3 ;
35037 PyObject * obj0 = 0 ;
35038 PyObject * obj1 = 0 ;
35039 PyObject * obj2 = 0 ;
35040 char * kwnames[] = {
35041 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35042 };
35043
35044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35046 if (!SWIG_IsOK(res1)) {
35047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35048 }
35049 arg1 = reinterpret_cast< wxWindow * >(argp1);
35050 {
35051 arg2 = &temp2;
35052 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35053 }
35054 if (obj2) {
35055 {
35056 arg3 = &temp3;
35057 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35058 }
35059 }
35060 {
35061 PyThreadState* __tstate = wxPyBeginAllowThreads();
35062 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35063 wxPyEndAllowThreads(__tstate);
35064 if (PyErr_Occurred()) SWIG_fail;
35065 }
35066 resultobj = SWIG_Py_Void();
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35074 PyObject *resultobj = 0;
35075 wxWindow *arg1 = (wxWindow *) 0 ;
35076 wxSize result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 PyObject *swig_obj[1] ;
35080
35081 if (!args) SWIG_fail;
35082 swig_obj[0] = args;
35083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35086 }
35087 arg1 = reinterpret_cast< wxWindow * >(argp1);
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 result = ((wxWindow const *)arg1)->GetMaxSize();
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35095 return resultobj;
35096 fail:
35097 return NULL;
35098 }
35099
35100
35101 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35102 PyObject *resultobj = 0;
35103 wxWindow *arg1 = (wxWindow *) 0 ;
35104 wxSize result;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 PyObject *swig_obj[1] ;
35108
35109 if (!args) SWIG_fail;
35110 swig_obj[0] = args;
35111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35114 }
35115 arg1 = reinterpret_cast< wxWindow * >(argp1);
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = ((wxWindow const *)arg1)->GetMinSize();
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35123 return resultobj;
35124 fail:
35125 return NULL;
35126 }
35127
35128
35129 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35130 PyObject *resultobj = 0;
35131 wxWindow *arg1 = (wxWindow *) 0 ;
35132 wxSize *arg2 = 0 ;
35133 void *argp1 = 0 ;
35134 int res1 = 0 ;
35135 wxSize temp2 ;
35136 PyObject * obj0 = 0 ;
35137 PyObject * obj1 = 0 ;
35138 char * kwnames[] = {
35139 (char *) "self",(char *) "minSize", NULL
35140 };
35141
35142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35144 if (!SWIG_IsOK(res1)) {
35145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35146 }
35147 arg1 = reinterpret_cast< wxWindow * >(argp1);
35148 {
35149 arg2 = &temp2;
35150 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35151 }
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 (arg1)->SetMinSize((wxSize const &)*arg2);
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 resultobj = SWIG_Py_Void();
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35166 PyObject *resultobj = 0;
35167 wxWindow *arg1 = (wxWindow *) 0 ;
35168 wxSize *arg2 = 0 ;
35169 void *argp1 = 0 ;
35170 int res1 = 0 ;
35171 wxSize temp2 ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 char * kwnames[] = {
35175 (char *) "self",(char *) "maxSize", NULL
35176 };
35177
35178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 {
35185 arg2 = &temp2;
35186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35187 }
35188 {
35189 PyThreadState* __tstate = wxPyBeginAllowThreads();
35190 (arg1)->SetMaxSize((wxSize const &)*arg2);
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 resultobj = SWIG_Py_Void();
35195 return resultobj;
35196 fail:
35197 return NULL;
35198 }
35199
35200
35201 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35202 PyObject *resultobj = 0;
35203 wxWindow *arg1 = (wxWindow *) 0 ;
35204 int result;
35205 void *argp1 = 0 ;
35206 int res1 = 0 ;
35207 PyObject *swig_obj[1] ;
35208
35209 if (!args) SWIG_fail;
35210 swig_obj[0] = args;
35211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35212 if (!SWIG_IsOK(res1)) {
35213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35214 }
35215 arg1 = reinterpret_cast< wxWindow * >(argp1);
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 resultobj = SWIG_From_int(static_cast< int >(result));
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35230 PyObject *resultobj = 0;
35231 wxWindow *arg1 = (wxWindow *) 0 ;
35232 int result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 PyObject *swig_obj[1] ;
35236
35237 if (!args) SWIG_fail;
35238 swig_obj[0] = args;
35239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35242 }
35243 arg1 = reinterpret_cast< wxWindow * >(argp1);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 resultobj = SWIG_From_int(static_cast< int >(result));
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 PyObject *resultobj = 0;
35259 wxWindow *arg1 = (wxWindow *) 0 ;
35260 int result;
35261 void *argp1 = 0 ;
35262 int res1 = 0 ;
35263 PyObject *swig_obj[1] ;
35264
35265 if (!args) SWIG_fail;
35266 swig_obj[0] = args;
35267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35268 if (!SWIG_IsOK(res1)) {
35269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35270 }
35271 arg1 = reinterpret_cast< wxWindow * >(argp1);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 resultobj = SWIG_From_int(static_cast< int >(result));
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35286 PyObject *resultobj = 0;
35287 wxWindow *arg1 = (wxWindow *) 0 ;
35288 int result;
35289 void *argp1 = 0 ;
35290 int res1 = 0 ;
35291 PyObject *swig_obj[1] ;
35292
35293 if (!args) SWIG_fail;
35294 swig_obj[0] = args;
35295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35296 if (!SWIG_IsOK(res1)) {
35297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35298 }
35299 arg1 = reinterpret_cast< wxWindow * >(argp1);
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 resultobj = SWIG_From_int(static_cast< int >(result));
35307 return resultobj;
35308 fail:
35309 return NULL;
35310 }
35311
35312
35313 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35314 PyObject *resultobj = 0;
35315 wxWindow *arg1 = (wxWindow *) 0 ;
35316 wxSize *arg2 = 0 ;
35317 void *argp1 = 0 ;
35318 int res1 = 0 ;
35319 wxSize temp2 ;
35320 PyObject * obj0 = 0 ;
35321 PyObject * obj1 = 0 ;
35322 char * kwnames[] = {
35323 (char *) "self",(char *) "size", NULL
35324 };
35325
35326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35328 if (!SWIG_IsOK(res1)) {
35329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35330 }
35331 arg1 = reinterpret_cast< wxWindow * >(argp1);
35332 {
35333 arg2 = &temp2;
35334 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35335 }
35336 {
35337 PyThreadState* __tstate = wxPyBeginAllowThreads();
35338 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35339 wxPyEndAllowThreads(__tstate);
35340 if (PyErr_Occurred()) SWIG_fail;
35341 }
35342 resultobj = SWIG_Py_Void();
35343 return resultobj;
35344 fail:
35345 return NULL;
35346 }
35347
35348
35349 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35350 PyObject *resultobj = 0;
35351 wxWindow *arg1 = (wxWindow *) 0 ;
35352 int arg2 ;
35353 int arg3 ;
35354 void *argp1 = 0 ;
35355 int res1 = 0 ;
35356 int val2 ;
35357 int ecode2 = 0 ;
35358 int val3 ;
35359 int ecode3 = 0 ;
35360 PyObject * obj0 = 0 ;
35361 PyObject * obj1 = 0 ;
35362 PyObject * obj2 = 0 ;
35363 char * kwnames[] = {
35364 (char *) "self",(char *) "w",(char *) "h", NULL
35365 };
35366
35367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35369 if (!SWIG_IsOK(res1)) {
35370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35371 }
35372 arg1 = reinterpret_cast< wxWindow * >(argp1);
35373 ecode2 = SWIG_AsVal_int(obj1, &val2);
35374 if (!SWIG_IsOK(ecode2)) {
35375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35376 }
35377 arg2 = static_cast< int >(val2);
35378 ecode3 = SWIG_AsVal_int(obj2, &val3);
35379 if (!SWIG_IsOK(ecode3)) {
35380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35381 }
35382 arg3 = static_cast< int >(val3);
35383 {
35384 PyThreadState* __tstate = wxPyBeginAllowThreads();
35385 (arg1)->SetVirtualSize(arg2,arg3);
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 resultobj = SWIG_Py_Void();
35390 return resultobj;
35391 fail:
35392 return NULL;
35393 }
35394
35395
35396 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35397 PyObject *resultobj = 0;
35398 wxWindow *arg1 = (wxWindow *) 0 ;
35399 wxSize result;
35400 void *argp1 = 0 ;
35401 int res1 = 0 ;
35402 PyObject *swig_obj[1] ;
35403
35404 if (!args) SWIG_fail;
35405 swig_obj[0] = args;
35406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35407 if (!SWIG_IsOK(res1)) {
35408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35409 }
35410 arg1 = reinterpret_cast< wxWindow * >(argp1);
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = ((wxWindow const *)arg1)->GetVirtualSize();
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35418 return resultobj;
35419 fail:
35420 return NULL;
35421 }
35422
35423
35424 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35425 PyObject *resultobj = 0;
35426 wxWindow *arg1 = (wxWindow *) 0 ;
35427 int *arg2 = (int *) 0 ;
35428 int *arg3 = (int *) 0 ;
35429 void *argp1 = 0 ;
35430 int res1 = 0 ;
35431 int temp2 ;
35432 int res2 = SWIG_TMPOBJ ;
35433 int temp3 ;
35434 int res3 = SWIG_TMPOBJ ;
35435 PyObject *swig_obj[1] ;
35436
35437 arg2 = &temp2;
35438 arg3 = &temp3;
35439 if (!args) SWIG_fail;
35440 swig_obj[0] = args;
35441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35442 if (!SWIG_IsOK(res1)) {
35443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35444 }
35445 arg1 = reinterpret_cast< wxWindow * >(argp1);
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35449 wxPyEndAllowThreads(__tstate);
35450 if (PyErr_Occurred()) SWIG_fail;
35451 }
35452 resultobj = SWIG_Py_Void();
35453 if (SWIG_IsTmpObj(res2)) {
35454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35455 } else {
35456 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35458 }
35459 if (SWIG_IsTmpObj(res3)) {
35460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35461 } else {
35462 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35464 }
35465 return resultobj;
35466 fail:
35467 return NULL;
35468 }
35469
35470
35471 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35472 PyObject *resultobj = 0;
35473 wxWindow *arg1 = (wxWindow *) 0 ;
35474 wxSize result;
35475 void *argp1 = 0 ;
35476 int res1 = 0 ;
35477 PyObject *swig_obj[1] ;
35478
35479 if (!args) SWIG_fail;
35480 swig_obj[0] = args;
35481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35500 PyObject *resultobj = 0;
35501 wxWindow *arg1 = (wxWindow *) 0 ;
35502 bool arg2 = (bool) true ;
35503 bool result;
35504 void *argp1 = 0 ;
35505 int res1 = 0 ;
35506 bool val2 ;
35507 int ecode2 = 0 ;
35508 PyObject * obj0 = 0 ;
35509 PyObject * obj1 = 0 ;
35510 char * kwnames[] = {
35511 (char *) "self",(char *) "show", NULL
35512 };
35513
35514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35518 }
35519 arg1 = reinterpret_cast< wxWindow * >(argp1);
35520 if (obj1) {
35521 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35522 if (!SWIG_IsOK(ecode2)) {
35523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35524 }
35525 arg2 = static_cast< bool >(val2);
35526 }
35527 {
35528 PyThreadState* __tstate = wxPyBeginAllowThreads();
35529 result = (bool)(arg1)->Show(arg2);
35530 wxPyEndAllowThreads(__tstate);
35531 if (PyErr_Occurred()) SWIG_fail;
35532 }
35533 {
35534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35535 }
35536 return resultobj;
35537 fail:
35538 return NULL;
35539 }
35540
35541
35542 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35543 PyObject *resultobj = 0;
35544 wxWindow *arg1 = (wxWindow *) 0 ;
35545 bool result;
35546 void *argp1 = 0 ;
35547 int res1 = 0 ;
35548 PyObject *swig_obj[1] ;
35549
35550 if (!args) SWIG_fail;
35551 swig_obj[0] = args;
35552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35553 if (!SWIG_IsOK(res1)) {
35554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35555 }
35556 arg1 = reinterpret_cast< wxWindow * >(argp1);
35557 {
35558 PyThreadState* __tstate = wxPyBeginAllowThreads();
35559 result = (bool)(arg1)->Hide();
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 {
35564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = 0;
35574 wxWindow *arg1 = (wxWindow *) 0 ;
35575 bool arg2 = (bool) true ;
35576 bool result;
35577 void *argp1 = 0 ;
35578 int res1 = 0 ;
35579 bool val2 ;
35580 int ecode2 = 0 ;
35581 PyObject * obj0 = 0 ;
35582 PyObject * obj1 = 0 ;
35583 char * kwnames[] = {
35584 (char *) "self",(char *) "enable", NULL
35585 };
35586
35587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35589 if (!SWIG_IsOK(res1)) {
35590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35591 }
35592 arg1 = reinterpret_cast< wxWindow * >(argp1);
35593 if (obj1) {
35594 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35595 if (!SWIG_IsOK(ecode2)) {
35596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35597 }
35598 arg2 = static_cast< bool >(val2);
35599 }
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 result = (bool)(arg1)->Enable(arg2);
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 {
35607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35608 }
35609 return resultobj;
35610 fail:
35611 return NULL;
35612 }
35613
35614
35615 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35616 PyObject *resultobj = 0;
35617 wxWindow *arg1 = (wxWindow *) 0 ;
35618 bool result;
35619 void *argp1 = 0 ;
35620 int res1 = 0 ;
35621 PyObject *swig_obj[1] ;
35622
35623 if (!args) SWIG_fail;
35624 swig_obj[0] = args;
35625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35626 if (!SWIG_IsOK(res1)) {
35627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35628 }
35629 arg1 = reinterpret_cast< wxWindow * >(argp1);
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 result = (bool)(arg1)->Disable();
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 {
35637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35638 }
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxWindow *arg1 = (wxWindow *) 0 ;
35648 bool result;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35658 }
35659 arg1 = reinterpret_cast< wxWindow * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 result = (bool)((wxWindow const *)arg1)->IsShown();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 {
35667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35676 PyObject *resultobj = 0;
35677 wxWindow *arg1 = (wxWindow *) 0 ;
35678 bool result;
35679 void *argp1 = 0 ;
35680 int res1 = 0 ;
35681 PyObject *swig_obj[1] ;
35682
35683 if (!args) SWIG_fail;
35684 swig_obj[0] = args;
35685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35686 if (!SWIG_IsOK(res1)) {
35687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35688 }
35689 arg1 = reinterpret_cast< wxWindow * >(argp1);
35690 {
35691 PyThreadState* __tstate = wxPyBeginAllowThreads();
35692 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35693 wxPyEndAllowThreads(__tstate);
35694 if (PyErr_Occurred()) SWIG_fail;
35695 }
35696 {
35697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35698 }
35699 return resultobj;
35700 fail:
35701 return NULL;
35702 }
35703
35704
35705 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35706 PyObject *resultobj = 0;
35707 wxWindow *arg1 = (wxWindow *) 0 ;
35708 bool result;
35709 void *argp1 = 0 ;
35710 int res1 = 0 ;
35711 PyObject *swig_obj[1] ;
35712
35713 if (!args) SWIG_fail;
35714 swig_obj[0] = args;
35715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35716 if (!SWIG_IsOK(res1)) {
35717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35718 }
35719 arg1 = reinterpret_cast< wxWindow * >(argp1);
35720 {
35721 PyThreadState* __tstate = wxPyBeginAllowThreads();
35722 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35723 wxPyEndAllowThreads(__tstate);
35724 if (PyErr_Occurred()) SWIG_fail;
35725 }
35726 {
35727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35728 }
35729 return resultobj;
35730 fail:
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj = 0;
35737 wxWindow *arg1 = (wxWindow *) 0 ;
35738 long arg2 ;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 long val2 ;
35742 int ecode2 = 0 ;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 char * kwnames[] = {
35746 (char *) "self",(char *) "style", NULL
35747 };
35748
35749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35751 if (!SWIG_IsOK(res1)) {
35752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35753 }
35754 arg1 = reinterpret_cast< wxWindow * >(argp1);
35755 ecode2 = SWIG_AsVal_long(obj1, &val2);
35756 if (!SWIG_IsOK(ecode2)) {
35757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35758 }
35759 arg2 = static_cast< long >(val2);
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 (arg1)->SetWindowStyleFlag(arg2);
35763 wxPyEndAllowThreads(__tstate);
35764 if (PyErr_Occurred()) SWIG_fail;
35765 }
35766 resultobj = SWIG_Py_Void();
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *resultobj = 0;
35775 wxWindow *arg1 = (wxWindow *) 0 ;
35776 long result;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 PyObject *swig_obj[1] ;
35780
35781 if (!args) SWIG_fail;
35782 swig_obj[0] = args;
35783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35786 }
35787 arg1 = reinterpret_cast< wxWindow * >(argp1);
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35791 wxPyEndAllowThreads(__tstate);
35792 if (PyErr_Occurred()) SWIG_fail;
35793 }
35794 resultobj = SWIG_From_long(static_cast< long >(result));
35795 return resultobj;
35796 fail:
35797 return NULL;
35798 }
35799
35800
35801 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35802 PyObject *resultobj = 0;
35803 wxWindow *arg1 = (wxWindow *) 0 ;
35804 int arg2 ;
35805 bool result;
35806 void *argp1 = 0 ;
35807 int res1 = 0 ;
35808 int val2 ;
35809 int ecode2 = 0 ;
35810 PyObject * obj0 = 0 ;
35811 PyObject * obj1 = 0 ;
35812 char * kwnames[] = {
35813 (char *) "self",(char *) "flag", NULL
35814 };
35815
35816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35818 if (!SWIG_IsOK(res1)) {
35819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35820 }
35821 arg1 = reinterpret_cast< wxWindow * >(argp1);
35822 ecode2 = SWIG_AsVal_int(obj1, &val2);
35823 if (!SWIG_IsOK(ecode2)) {
35824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35825 }
35826 arg2 = static_cast< int >(val2);
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 {
35834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35835 }
35836 return resultobj;
35837 fail:
35838 return NULL;
35839 }
35840
35841
35842 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35843 PyObject *resultobj = 0;
35844 wxWindow *arg1 = (wxWindow *) 0 ;
35845 bool result;
35846 void *argp1 = 0 ;
35847 int res1 = 0 ;
35848 PyObject *swig_obj[1] ;
35849
35850 if (!args) SWIG_fail;
35851 swig_obj[0] = args;
35852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35853 if (!SWIG_IsOK(res1)) {
35854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35855 }
35856 arg1 = reinterpret_cast< wxWindow * >(argp1);
35857 {
35858 PyThreadState* __tstate = wxPyBeginAllowThreads();
35859 result = (bool)((wxWindow const *)arg1)->IsRetained();
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 {
35864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35865 }
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 wxWindow *arg1 = (wxWindow *) 0 ;
35875 long arg2 ;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 long val2 ;
35879 int ecode2 = 0 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "exStyle", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35890 }
35891 arg1 = reinterpret_cast< wxWindow * >(argp1);
35892 ecode2 = SWIG_AsVal_long(obj1, &val2);
35893 if (!SWIG_IsOK(ecode2)) {
35894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35895 }
35896 arg2 = static_cast< long >(val2);
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->SetExtraStyle(arg2);
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 resultobj = SWIG_Py_Void();
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35911 PyObject *resultobj = 0;
35912 wxWindow *arg1 = (wxWindow *) 0 ;
35913 long result;
35914 void *argp1 = 0 ;
35915 int res1 = 0 ;
35916 PyObject *swig_obj[1] ;
35917
35918 if (!args) SWIG_fail;
35919 swig_obj[0] = args;
35920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_From_long(static_cast< long >(result));
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 bool arg2 = (bool) true ;
35942 void *argp1 = 0 ;
35943 int res1 = 0 ;
35944 bool val2 ;
35945 int ecode2 = 0 ;
35946 PyObject * obj0 = 0 ;
35947 PyObject * obj1 = 0 ;
35948 char * kwnames[] = {
35949 (char *) "self",(char *) "modal", NULL
35950 };
35951
35952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35956 }
35957 arg1 = reinterpret_cast< wxWindow * >(argp1);
35958 if (obj1) {
35959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35960 if (!SWIG_IsOK(ecode2)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35962 }
35963 arg2 = static_cast< bool >(val2);
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 (arg1)->MakeModal(arg2);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_Py_Void();
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 bool arg2 ;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 bool val2 ;
35985 int ecode2 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "enableTheme", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35996 }
35997 arg1 = reinterpret_cast< wxWindow * >(argp1);
35998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35999 if (!SWIG_IsOK(ecode2)) {
36000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36001 }
36002 arg2 = static_cast< bool >(val2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 (arg1)->SetThemeEnabled(arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_Py_Void();
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 bool 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_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 {
36038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36039 }
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxWindow *arg1 = (wxWindow *) 0 ;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 PyObject *swig_obj[1] ;
36052
36053 if (!args) SWIG_fail;
36054 swig_obj[0] = args;
36055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36056 if (!SWIG_IsOK(res1)) {
36057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36058 }
36059 arg1 = reinterpret_cast< wxWindow * >(argp1);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 (arg1)->SetFocus();
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 resultobj = SWIG_Py_Void();
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36074 PyObject *resultobj = 0;
36075 wxWindow *arg1 = (wxWindow *) 0 ;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 (arg1)->SetFocusFromKbd();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_Py_Void();
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 PyObject *resultobj = 0;
36102 wxWindow *result = 0 ;
36103
36104 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36105 {
36106 if (!wxPyCheckForApp()) SWIG_fail;
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (wxWindow *)wxWindow::FindFocus();
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 {
36113 resultobj = wxPyMake_wxObject(result, 0);
36114 }
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36122 PyObject *resultobj = 0;
36123 wxWindow *arg1 = (wxWindow *) 0 ;
36124 bool result;
36125 void *argp1 = 0 ;
36126 int res1 = 0 ;
36127 PyObject *swig_obj[1] ;
36128
36129 if (!args) SWIG_fail;
36130 swig_obj[0] = args;
36131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36134 }
36135 arg1 = reinterpret_cast< wxWindow * >(argp1);
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36144 }
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 PyObject *swig_obj[1] ;
36158
36159 if (!args) SWIG_fail;
36160 swig_obj[0] = args;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36174 }
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36182 PyObject *resultobj = 0;
36183 wxWindow *arg1 = (wxWindow *) 0 ;
36184 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36185 bool result;
36186 void *argp1 = 0 ;
36187 int res1 = 0 ;
36188 int val2 ;
36189 int ecode2 = 0 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "flags", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 if (obj1) {
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 }
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 result = (bool)(arg1)->Navigate(arg2);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 {
36216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36217 }
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 wxWindow *arg2 = (wxWindow *) 0 ;
36228 void *argp1 = 0 ;
36229 int res1 = 0 ;
36230 void *argp2 = 0 ;
36231 int res2 = 0 ;
36232 PyObject * obj0 = 0 ;
36233 PyObject * obj1 = 0 ;
36234 char * kwnames[] = {
36235 (char *) "self",(char *) "win", NULL
36236 };
36237
36238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res2)) {
36246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36247 }
36248 arg2 = reinterpret_cast< wxWindow * >(argp2);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 (arg1)->MoveAfterInTabOrder(arg2);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 wxWindow *arg2 = (wxWindow *) 0 ;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 void *argp2 = 0 ;
36269 int res2 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char * kwnames[] = {
36273 (char *) "self",(char *) "win", NULL
36274 };
36275
36276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36278 if (!SWIG_IsOK(res1)) {
36279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36280 }
36281 arg1 = reinterpret_cast< wxWindow * >(argp1);
36282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36283 if (!SWIG_IsOK(res2)) {
36284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36285 }
36286 arg2 = reinterpret_cast< wxWindow * >(argp2);
36287 {
36288 PyThreadState* __tstate = wxPyBeginAllowThreads();
36289 (arg1)->MoveBeforeInTabOrder(arg2);
36290 wxPyEndAllowThreads(__tstate);
36291 if (PyErr_Occurred()) SWIG_fail;
36292 }
36293 resultobj = SWIG_Py_Void();
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36301 PyObject *resultobj = 0;
36302 wxWindow *arg1 = (wxWindow *) 0 ;
36303 PyObject *result = 0 ;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 PyObject *swig_obj[1] ;
36307
36308 if (!args) SWIG_fail;
36309 swig_obj[0] = args;
36310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36313 }
36314 arg1 = reinterpret_cast< wxWindow * >(argp1);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (PyObject *)wxWindow_GetChildren(arg1);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = result;
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxWindow *arg1 = (wxWindow *) 0 ;
36331 wxWindow *result = 0 ;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 PyObject *swig_obj[1] ;
36335
36336 if (!args) SWIG_fail;
36337 swig_obj[0] = args;
36338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 resultobj = wxPyMake_wxObject(result, 0);
36351 }
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36359 PyObject *resultobj = 0;
36360 wxWindow *arg1 = (wxWindow *) 0 ;
36361 wxWindow *result = 0 ;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 PyObject *swig_obj[1] ;
36365
36366 if (!args) SWIG_fail;
36367 swig_obj[0] = args;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36371 }
36372 arg1 = reinterpret_cast< wxWindow * >(argp1);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 {
36380 resultobj = wxPyMake_wxObject(result, 0);
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 bool result;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 PyObject *swig_obj[1] ;
36395
36396 if (!args) SWIG_fail;
36397 swig_obj[0] = args;
36398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36401 }
36402 arg1 = reinterpret_cast< wxWindow * >(argp1);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 {
36410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 wxWindow *arg2 = (wxWindow *) 0 ;
36422 bool result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 void *argp2 = 0 ;
36426 int res2 = 0 ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 char * kwnames[] = {
36430 (char *) "self",(char *) "newParent", NULL
36431 };
36432
36433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36435 if (!SWIG_IsOK(res1)) {
36436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36437 }
36438 arg1 = reinterpret_cast< wxWindow * >(argp1);
36439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res2)) {
36441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36442 }
36443 arg2 = reinterpret_cast< wxWindow * >(argp2);
36444 {
36445 PyThreadState* __tstate = wxPyBeginAllowThreads();
36446 result = (bool)(arg1)->Reparent(arg2);
36447 wxPyEndAllowThreads(__tstate);
36448 if (PyErr_Occurred()) SWIG_fail;
36449 }
36450 {
36451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36452 }
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 wxWindow *arg2 = (wxWindow *) 0 ;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 void *argp2 = 0 ;
36466 int res2 = 0 ;
36467 PyObject * obj0 = 0 ;
36468 PyObject * obj1 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "child", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36480 if (!SWIG_IsOK(res2)) {
36481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36482 }
36483 arg2 = reinterpret_cast< wxWindow * >(argp2);
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 (arg1)->AddChild(arg2);
36487 wxPyEndAllowThreads(__tstate);
36488 if (PyErr_Occurred()) SWIG_fail;
36489 }
36490 resultobj = SWIG_Py_Void();
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36498 PyObject *resultobj = 0;
36499 wxWindow *arg1 = (wxWindow *) 0 ;
36500 wxWindow *arg2 = (wxWindow *) 0 ;
36501 void *argp1 = 0 ;
36502 int res1 = 0 ;
36503 void *argp2 = 0 ;
36504 int res2 = 0 ;
36505 PyObject * obj0 = 0 ;
36506 PyObject * obj1 = 0 ;
36507 char * kwnames[] = {
36508 (char *) "self",(char *) "child", NULL
36509 };
36510
36511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res1)) {
36514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36515 }
36516 arg1 = reinterpret_cast< wxWindow * >(argp1);
36517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36518 if (!SWIG_IsOK(res2)) {
36519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36520 }
36521 arg2 = reinterpret_cast< wxWindow * >(argp2);
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->RemoveChild(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 resultobj = SWIG_Py_Void();
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj = 0;
36537 wxWindow *arg1 = (wxWindow *) 0 ;
36538 bool arg2 ;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 bool val2 ;
36542 int ecode2 = 0 ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 char * kwnames[] = {
36546 (char *) "self",(char *) "on", NULL
36547 };
36548
36549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res1)) {
36552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36553 }
36554 arg1 = reinterpret_cast< wxWindow * >(argp1);
36555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36556 if (!SWIG_IsOK(ecode2)) {
36557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36558 }
36559 arg2 = static_cast< bool >(val2);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 wxWindow_SetDoubleBuffered(arg1,arg2);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_Py_Void();
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 long arg2 ;
36577 wxWindow *result = 0 ;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 long val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "winid", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_long(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36597 }
36598 arg2 = static_cast< long >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (wxWindow *)(arg1)->FindWindow(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 {
36606 resultobj = wxPyMake_wxObject(result, 0);
36607 }
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 wxString *arg2 = 0 ;
36618 wxWindow *result = 0 ;
36619 void *argp1 = 0 ;
36620 int res1 = 0 ;
36621 bool temp2 = false ;
36622 PyObject * obj0 = 0 ;
36623 PyObject * obj1 = 0 ;
36624 char * kwnames[] = {
36625 (char *) "self",(char *) "name", NULL
36626 };
36627
36628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36630 if (!SWIG_IsOK(res1)) {
36631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36632 }
36633 arg1 = reinterpret_cast< wxWindow * >(argp1);
36634 {
36635 arg2 = wxString_in_helper(obj1);
36636 if (arg2 == NULL) SWIG_fail;
36637 temp2 = true;
36638 }
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 {
36646 resultobj = wxPyMake_wxObject(result, 0);
36647 }
36648 {
36649 if (temp2)
36650 delete arg2;
36651 }
36652 return resultobj;
36653 fail:
36654 {
36655 if (temp2)
36656 delete arg2;
36657 }
36658 return NULL;
36659 }
36660
36661
36662 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36663 PyObject *resultobj = 0;
36664 wxWindow *arg1 = (wxWindow *) 0 ;
36665 wxEvtHandler *result = 0 ;
36666 void *argp1 = 0 ;
36667 int res1 = 0 ;
36668 PyObject *swig_obj[1] ;
36669
36670 if (!args) SWIG_fail;
36671 swig_obj[0] = args;
36672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36673 if (!SWIG_IsOK(res1)) {
36674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36675 }
36676 arg1 = reinterpret_cast< wxWindow * >(argp1);
36677 {
36678 PyThreadState* __tstate = wxPyBeginAllowThreads();
36679 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 {
36684 resultobj = wxPyMake_wxObject(result, 0);
36685 }
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36693 PyObject *resultobj = 0;
36694 wxWindow *arg1 = (wxWindow *) 0 ;
36695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36696 void *argp1 = 0 ;
36697 int res1 = 0 ;
36698 void *argp2 = 0 ;
36699 int res2 = 0 ;
36700 PyObject * obj0 = 0 ;
36701 PyObject * obj1 = 0 ;
36702 char * kwnames[] = {
36703 (char *) "self",(char *) "handler", NULL
36704 };
36705
36706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36708 if (!SWIG_IsOK(res1)) {
36709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36710 }
36711 arg1 = reinterpret_cast< wxWindow * >(argp1);
36712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36713 if (!SWIG_IsOK(res2)) {
36714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36715 }
36716 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 (arg1)->SetEventHandler(arg2);
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 resultobj = SWIG_Py_Void();
36724 return resultobj;
36725 fail:
36726 return NULL;
36727 }
36728
36729
36730 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36731 PyObject *resultobj = 0;
36732 wxWindow *arg1 = (wxWindow *) 0 ;
36733 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36734 void *argp1 = 0 ;
36735 int res1 = 0 ;
36736 void *argp2 = 0 ;
36737 int res2 = 0 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char * kwnames[] = {
36741 (char *) "self",(char *) "handler", NULL
36742 };
36743
36744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36748 }
36749 arg1 = reinterpret_cast< wxWindow * >(argp1);
36750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36751 if (!SWIG_IsOK(res2)) {
36752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36753 }
36754 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 (arg1)->PushEventHandler(arg2);
36758 wxPyEndAllowThreads(__tstate);
36759 if (PyErr_Occurred()) SWIG_fail;
36760 }
36761 resultobj = SWIG_Py_Void();
36762 return resultobj;
36763 fail:
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 bool arg2 = (bool) false ;
36772 wxEvtHandler *result = 0 ;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 bool val2 ;
36776 int ecode2 = 0 ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 char * kwnames[] = {
36780 (char *) "self",(char *) "deleteHandler", NULL
36781 };
36782
36783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36787 }
36788 arg1 = reinterpret_cast< wxWindow * >(argp1);
36789 if (obj1) {
36790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36791 if (!SWIG_IsOK(ecode2)) {
36792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36793 }
36794 arg2 = static_cast< bool >(val2);
36795 }
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 {
36803 resultobj = wxPyMake_wxObject(result, 0);
36804 }
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36815 bool result;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 void *argp2 = 0 ;
36819 int res2 = 0 ;
36820 PyObject * obj0 = 0 ;
36821 PyObject * obj1 = 0 ;
36822 char * kwnames[] = {
36823 (char *) "self",(char *) "handler", NULL
36824 };
36825
36826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36833 if (!SWIG_IsOK(res2)) {
36834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36835 }
36836 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = (bool)(arg1)->RemoveEventHandler(arg2);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = 0;
36854 wxWindow *arg1 = (wxWindow *) 0 ;
36855 wxValidator *arg2 = 0 ;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 void *argp2 = 0 ;
36859 int res2 = 0 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "validator", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36873 if (!SWIG_IsOK(res2)) {
36874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36875 }
36876 if (!argp2) {
36877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36878 }
36879 arg2 = reinterpret_cast< wxValidator * >(argp2);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->SetValidator((wxValidator const &)*arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36894 PyObject *resultobj = 0;
36895 wxWindow *arg1 = (wxWindow *) 0 ;
36896 wxValidator *result = 0 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 PyObject *swig_obj[1] ;
36900
36901 if (!args) SWIG_fail;
36902 swig_obj[0] = args;
36903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36904 if (!SWIG_IsOK(res1)) {
36905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36906 }
36907 arg1 = reinterpret_cast< wxWindow * >(argp1);
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 result = (wxValidator *)(arg1)->GetValidator();
36911 wxPyEndAllowThreads(__tstate);
36912 if (PyErr_Occurred()) SWIG_fail;
36913 }
36914 {
36915 resultobj = wxPyMake_wxObject(result, (bool)0);
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36924 PyObject *resultobj = 0;
36925 wxWindow *arg1 = (wxWindow *) 0 ;
36926 bool result;
36927 void *argp1 = 0 ;
36928 int res1 = 0 ;
36929 PyObject *swig_obj[1] ;
36930
36931 if (!args) SWIG_fail;
36932 swig_obj[0] = args;
36933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36934 if (!SWIG_IsOK(res1)) {
36935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36936 }
36937 arg1 = reinterpret_cast< wxWindow * >(argp1);
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 result = (bool)(arg1)->Validate();
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 {
36945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36954 PyObject *resultobj = 0;
36955 wxWindow *arg1 = (wxWindow *) 0 ;
36956 bool result;
36957 void *argp1 = 0 ;
36958 int res1 = 0 ;
36959 PyObject *swig_obj[1] ;
36960
36961 if (!args) SWIG_fail;
36962 swig_obj[0] = args;
36963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36966 }
36967 arg1 = reinterpret_cast< wxWindow * >(argp1);
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = (bool)(arg1)->TransferDataToWindow();
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36976 }
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxWindow *arg1 = (wxWindow *) 0 ;
36986 bool result;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (bool)(arg1)->TransferDataFromWindow();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37006 }
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 PyObject *swig_obj[1] ;
37019
37020 if (!args) SWIG_fail;
37021 swig_obj[0] = args;
37022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37025 }
37026 arg1 = reinterpret_cast< wxWindow * >(argp1);
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 (arg1)->InitDialog();
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 resultobj = SWIG_Py_Void();
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37041 PyObject *resultobj = 0;
37042 wxWindow *arg1 = (wxWindow *) 0 ;
37043 wxAcceleratorTable *arg2 = 0 ;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 void *argp2 = 0 ;
37047 int res2 = 0 ;
37048 PyObject * obj0 = 0 ;
37049 PyObject * obj1 = 0 ;
37050 char * kwnames[] = {
37051 (char *) "self",(char *) "accel", NULL
37052 };
37053
37054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37056 if (!SWIG_IsOK(res1)) {
37057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37058 }
37059 arg1 = reinterpret_cast< wxWindow * >(argp1);
37060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37061 if (!SWIG_IsOK(res2)) {
37062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37063 }
37064 if (!argp2) {
37065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37066 }
37067 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 resultobj = SWIG_Py_Void();
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 wxAcceleratorTable *result = 0 ;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 PyObject *swig_obj[1] ;
37088
37089 if (!args) SWIG_fail;
37090 swig_obj[0] = args;
37091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37092 if (!SWIG_IsOK(res1)) {
37093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37094 }
37095 arg1 = reinterpret_cast< wxWindow * >(argp1);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 int arg2 ;
37113 int arg3 ;
37114 int arg4 ;
37115 bool result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 int val2 ;
37119 int ecode2 = 0 ;
37120 int val3 ;
37121 int ecode3 = 0 ;
37122 int val4 ;
37123 int ecode4 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 PyObject * obj2 = 0 ;
37127 PyObject * obj3 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37136 }
37137 arg1 = reinterpret_cast< wxWindow * >(argp1);
37138 ecode2 = SWIG_AsVal_int(obj1, &val2);
37139 if (!SWIG_IsOK(ecode2)) {
37140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37141 }
37142 arg2 = static_cast< int >(val2);
37143 ecode3 = SWIG_AsVal_int(obj2, &val3);
37144 if (!SWIG_IsOK(ecode3)) {
37145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37146 }
37147 arg3 = static_cast< int >(val3);
37148 ecode4 = SWIG_AsVal_int(obj3, &val4);
37149 if (!SWIG_IsOK(ecode4)) {
37150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37151 }
37152 arg4 = static_cast< int >(val4);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 int arg2 ;
37172 bool result;
37173 void *argp1 = 0 ;
37174 int res1 = 0 ;
37175 int val2 ;
37176 int ecode2 = 0 ;
37177 PyObject * obj0 = 0 ;
37178 PyObject * obj1 = 0 ;
37179 char * kwnames[] = {
37180 (char *) "self",(char *) "hotkeyId", NULL
37181 };
37182
37183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37185 if (!SWIG_IsOK(res1)) {
37186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37187 }
37188 arg1 = reinterpret_cast< wxWindow * >(argp1);
37189 ecode2 = SWIG_AsVal_int(obj1, &val2);
37190 if (!SWIG_IsOK(ecode2)) {
37191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37192 }
37193 arg2 = static_cast< int >(val2);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37202 }
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 wxPoint *arg2 = 0 ;
37213 wxPoint result;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 wxPoint temp2 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "pt", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 {
37230 arg2 = &temp2;
37231 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 wxSize *arg2 = 0 ;
37250 wxSize result;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 wxSize temp2 ;
37254 PyObject * obj0 = 0 ;
37255 PyObject * obj1 = 0 ;
37256 char * kwnames[] = {
37257 (char *) "self",(char *) "sz", NULL
37258 };
37259
37260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 {
37267 arg2 = &temp2;
37268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37277 return resultobj;
37278 fail:
37279 return NULL;
37280 }
37281
37282
37283 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj = 0;
37285 wxWindow *arg1 = (wxWindow *) 0 ;
37286 wxPoint *arg2 = 0 ;
37287 wxPoint result;
37288 void *argp1 = 0 ;
37289 int res1 = 0 ;
37290 wxPoint temp2 ;
37291 PyObject * obj0 = 0 ;
37292 PyObject * obj1 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "pt", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 {
37304 arg2 = &temp2;
37305 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37306 }
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37310 wxPyEndAllowThreads(__tstate);
37311 if (PyErr_Occurred()) SWIG_fail;
37312 }
37313 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37314 return resultobj;
37315 fail:
37316 return NULL;
37317 }
37318
37319
37320 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37321 PyObject *resultobj = 0;
37322 wxWindow *arg1 = (wxWindow *) 0 ;
37323 wxSize *arg2 = 0 ;
37324 wxSize result;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 wxSize temp2 ;
37328 PyObject * obj0 = 0 ;
37329 PyObject * obj1 = 0 ;
37330 char * kwnames[] = {
37331 (char *) "self",(char *) "sz", NULL
37332 };
37333
37334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 {
37341 arg2 = &temp2;
37342 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37343 }
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxPoint *arg2 = 0 ;
37361 wxPoint result;
37362 void *argp1 = 0 ;
37363 int res1 = 0 ;
37364 wxPoint temp2 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 char * kwnames[] = {
37368 (char *) "self",(char *) "pt", NULL
37369 };
37370
37371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 {
37378 arg2 = &temp2;
37379 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37380 }
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 wxSize *arg2 = 0 ;
37398 wxSize result;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 wxSize temp2 ;
37402 PyObject * obj0 = 0 ;
37403 PyObject * obj1 = 0 ;
37404 char * kwnames[] = {
37405 (char *) "self",(char *) "sz", NULL
37406 };
37407
37408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 {
37415 arg2 = &temp2;
37416 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37432 PyObject *resultobj = 0;
37433 wxWindow *arg1 = (wxWindow *) 0 ;
37434 int arg2 ;
37435 int arg3 ;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 int val2 ;
37439 int ecode2 = 0 ;
37440 int val3 ;
37441 int ecode3 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 PyObject * obj2 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "x",(char *) "y", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 ecode2 = SWIG_AsVal_int(obj1, &val2);
37456 if (!SWIG_IsOK(ecode2)) {
37457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37458 }
37459 arg2 = static_cast< int >(val2);
37460 ecode3 = SWIG_AsVal_int(obj2, &val3);
37461 if (!SWIG_IsOK(ecode3)) {
37462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37463 }
37464 arg3 = static_cast< int >(val3);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 (arg1)->WarpPointer(arg2,arg3);
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 resultobj = SWIG_Py_Void();
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37479 PyObject *resultobj = 0;
37480 wxWindow *arg1 = (wxWindow *) 0 ;
37481 void *argp1 = 0 ;
37482 int res1 = 0 ;
37483 PyObject *swig_obj[1] ;
37484
37485 if (!args) SWIG_fail;
37486 swig_obj[0] = args;
37487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res1)) {
37489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37490 }
37491 arg1 = reinterpret_cast< wxWindow * >(argp1);
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 (arg1)->CaptureMouse();
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_Py_Void();
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 PyObject *swig_obj[1] ;
37511
37512 if (!args) SWIG_fail;
37513 swig_obj[0] = args;
37514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37515 if (!SWIG_IsOK(res1)) {
37516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37517 }
37518 arg1 = reinterpret_cast< wxWindow * >(argp1);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 (arg1)->ReleaseMouse();
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 resultobj = SWIG_Py_Void();
37526 return resultobj;
37527 fail:
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37533 PyObject *resultobj = 0;
37534 wxWindow *result = 0 ;
37535
37536 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37537 {
37538 if (!wxPyCheckForApp()) SWIG_fail;
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 result = (wxWindow *)wxWindow::GetCapture();
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 {
37545 resultobj = wxPyMake_wxObject(result, 0);
37546 }
37547 return resultobj;
37548 fail:
37549 return NULL;
37550 }
37551
37552
37553 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37554 PyObject *resultobj = 0;
37555 wxWindow *arg1 = (wxWindow *) 0 ;
37556 bool result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 PyObject *swig_obj[1] ;
37560
37561 if (!args) SWIG_fail;
37562 swig_obj[0] = args;
37563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37564 if (!SWIG_IsOK(res1)) {
37565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37566 }
37567 arg1 = reinterpret_cast< wxWindow * >(argp1);
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (bool)((wxWindow const *)arg1)->HasCapture();
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 {
37575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37576 }
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = 0;
37585 wxWindow *arg1 = (wxWindow *) 0 ;
37586 bool arg2 = (bool) true ;
37587 wxRect *arg3 = (wxRect *) NULL ;
37588 void *argp1 = 0 ;
37589 int res1 = 0 ;
37590 bool val2 ;
37591 int ecode2 = 0 ;
37592 void *argp3 = 0 ;
37593 int res3 = 0 ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 PyObject * obj2 = 0 ;
37597 char * kwnames[] = {
37598 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37599 };
37600
37601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37605 }
37606 arg1 = reinterpret_cast< wxWindow * >(argp1);
37607 if (obj1) {
37608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37609 if (!SWIG_IsOK(ecode2)) {
37610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37611 }
37612 arg2 = static_cast< bool >(val2);
37613 }
37614 if (obj2) {
37615 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37616 if (!SWIG_IsOK(res3)) {
37617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37618 }
37619 arg3 = reinterpret_cast< wxRect * >(argp3);
37620 }
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 resultobj = SWIG_Py_Void();
37628 return resultobj;
37629 fail:
37630 return NULL;
37631 }
37632
37633
37634 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37635 PyObject *resultobj = 0;
37636 wxWindow *arg1 = (wxWindow *) 0 ;
37637 wxRect *arg2 = 0 ;
37638 bool arg3 = (bool) true ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 wxRect temp2 ;
37642 bool val3 ;
37643 int ecode3 = 0 ;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 PyObject * obj2 = 0 ;
37647 char * kwnames[] = {
37648 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37649 };
37650
37651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37653 if (!SWIG_IsOK(res1)) {
37654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37655 }
37656 arg1 = reinterpret_cast< wxWindow * >(argp1);
37657 {
37658 arg2 = &temp2;
37659 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37660 }
37661 if (obj2) {
37662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37663 if (!SWIG_IsOK(ecode3)) {
37664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37665 }
37666 arg3 = static_cast< bool >(val3);
37667 }
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37671 wxPyEndAllowThreads(__tstate);
37672 if (PyErr_Occurred()) SWIG_fail;
37673 }
37674 resultobj = SWIG_Py_Void();
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *resultobj = 0;
37683 wxWindow *arg1 = (wxWindow *) 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 (arg1)->Update();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 resultobj = SWIG_Py_Void();
37702 return resultobj;
37703 fail:
37704 return NULL;
37705 }
37706
37707
37708 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37709 PyObject *resultobj = 0;
37710 wxWindow *arg1 = (wxWindow *) 0 ;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 PyObject *swig_obj[1] ;
37714
37715 if (!args) SWIG_fail;
37716 swig_obj[0] = args;
37717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37718 if (!SWIG_IsOK(res1)) {
37719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37720 }
37721 arg1 = reinterpret_cast< wxWindow * >(argp1);
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 (arg1)->ClearBackground();
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 resultobj = SWIG_Py_Void();
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxWindow *arg1 = (wxWindow *) 0 ;
37738 void *argp1 = 0 ;
37739 int res1 = 0 ;
37740 PyObject *swig_obj[1] ;
37741
37742 if (!args) SWIG_fail;
37743 swig_obj[0] = args;
37744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37745 if (!SWIG_IsOK(res1)) {
37746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37747 }
37748 arg1 = reinterpret_cast< wxWindow * >(argp1);
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 (arg1)->Freeze();
37752 wxPyEndAllowThreads(__tstate);
37753 if (PyErr_Occurred()) SWIG_fail;
37754 }
37755 resultobj = SWIG_Py_Void();
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37763 PyObject *resultobj = 0;
37764 wxWindow *arg1 = (wxWindow *) 0 ;
37765 bool result;
37766 void *argp1 = 0 ;
37767 int res1 = 0 ;
37768 PyObject *swig_obj[1] ;
37769
37770 if (!args) SWIG_fail;
37771 swig_obj[0] = args;
37772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37773 if (!SWIG_IsOK(res1)) {
37774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37775 }
37776 arg1 = reinterpret_cast< wxWindow * >(argp1);
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37785 }
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxWindow *arg1 = (wxWindow *) 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37804 }
37805 arg1 = reinterpret_cast< wxWindow * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 (arg1)->Thaw();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_Py_Void();
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 wxDC *arg2 = 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 void *argp2 = 0 ;
37826 int res2 = 0 ;
37827 PyObject * obj0 = 0 ;
37828 PyObject * obj1 = 0 ;
37829 char * kwnames[] = {
37830 (char *) "self",(char *) "dc", NULL
37831 };
37832
37833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37840 if (!SWIG_IsOK(res2)) {
37841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37842 }
37843 if (!argp2) {
37844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37845 }
37846 arg2 = reinterpret_cast< wxDC * >(argp2);
37847 {
37848 PyThreadState* __tstate = wxPyBeginAllowThreads();
37849 (arg1)->PrepareDC(*arg2);
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 resultobj = SWIG_Py_Void();
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 bool result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37873 }
37874 arg1 = reinterpret_cast< wxWindow * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37883 }
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *arg1 = (wxWindow *) 0 ;
37893 wxRegion *result = 0 ;
37894 void *argp1 = 0 ;
37895 int res1 = 0 ;
37896 PyObject *swig_obj[1] ;
37897
37898 if (!args) SWIG_fail;
37899 swig_obj[0] = args;
37900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37901 if (!SWIG_IsOK(res1)) {
37902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37903 }
37904 arg1 = reinterpret_cast< wxWindow * >(argp1);
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 {
37908 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37909 result = (wxRegion *) &_result_ref;
37910 }
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxWindow *arg1 = (wxWindow *) 0 ;
37924 wxRect result;
37925 void *argp1 = 0 ;
37926 int res1 = 0 ;
37927 PyObject *swig_obj[1] ;
37928
37929 if (!args) SWIG_fail;
37930 swig_obj[0] = args;
37931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37934 }
37935 arg1 = reinterpret_cast< wxWindow * >(argp1);
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37950 PyObject *resultobj = 0;
37951 wxWindow *arg1 = (wxWindow *) 0 ;
37952 int arg2 ;
37953 int arg3 ;
37954 int arg4 = (int) 1 ;
37955 int arg5 = (int) 1 ;
37956 bool result;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 int val2 ;
37960 int ecode2 = 0 ;
37961 int val3 ;
37962 int ecode3 = 0 ;
37963 int val4 ;
37964 int ecode4 = 0 ;
37965 int val5 ;
37966 int ecode5 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 PyObject * obj4 = 0 ;
37972 char * kwnames[] = {
37973 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37974 };
37975
37976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37980 }
37981 arg1 = reinterpret_cast< wxWindow * >(argp1);
37982 ecode2 = SWIG_AsVal_int(obj1, &val2);
37983 if (!SWIG_IsOK(ecode2)) {
37984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37985 }
37986 arg2 = static_cast< int >(val2);
37987 ecode3 = SWIG_AsVal_int(obj2, &val3);
37988 if (!SWIG_IsOK(ecode3)) {
37989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37990 }
37991 arg3 = static_cast< int >(val3);
37992 if (obj3) {
37993 ecode4 = SWIG_AsVal_int(obj3, &val4);
37994 if (!SWIG_IsOK(ecode4)) {
37995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37996 }
37997 arg4 = static_cast< int >(val4);
37998 }
37999 if (obj4) {
38000 ecode5 = SWIG_AsVal_int(obj4, &val5);
38001 if (!SWIG_IsOK(ecode5)) {
38002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38003 }
38004 arg5 = static_cast< int >(val5);
38005 }
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38014 }
38015 return resultobj;
38016 fail:
38017 return NULL;
38018 }
38019
38020
38021 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj = 0;
38023 wxWindow *arg1 = (wxWindow *) 0 ;
38024 wxPoint *arg2 = 0 ;
38025 bool result;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 wxPoint temp2 ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 char * kwnames[] = {
38032 (char *) "self",(char *) "pt", NULL
38033 };
38034
38035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38037 if (!SWIG_IsOK(res1)) {
38038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38039 }
38040 arg1 = reinterpret_cast< wxWindow * >(argp1);
38041 {
38042 arg2 = &temp2;
38043 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38044 }
38045 {
38046 PyThreadState* __tstate = wxPyBeginAllowThreads();
38047 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38048 wxPyEndAllowThreads(__tstate);
38049 if (PyErr_Occurred()) SWIG_fail;
38050 }
38051 {
38052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38053 }
38054 return resultobj;
38055 fail:
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxWindow *arg1 = (wxWindow *) 0 ;
38063 wxRect *arg2 = 0 ;
38064 bool result;
38065 void *argp1 = 0 ;
38066 int res1 = 0 ;
38067 wxRect temp2 ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "self",(char *) "rect", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 arg2 = &temp2;
38082 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38083 }
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 {
38091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38092 }
38093 return resultobj;
38094 fail:
38095 return NULL;
38096 }
38097
38098
38099 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38100 PyObject *resultobj = 0;
38101 wxWindow *arg1 = (wxWindow *) 0 ;
38102 SwigValueWrapper<wxVisualAttributes > result;
38103 void *argp1 = 0 ;
38104 int res1 = 0 ;
38105 PyObject *swig_obj[1] ;
38106
38107 if (!args) SWIG_fail;
38108 swig_obj[0] = args;
38109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38121 return resultobj;
38122 fail:
38123 return NULL;
38124 }
38125
38126
38127 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38128 PyObject *resultobj = 0;
38129 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38130 SwigValueWrapper<wxVisualAttributes > result;
38131 int val1 ;
38132 int ecode1 = 0 ;
38133 PyObject * obj0 = 0 ;
38134 char * kwnames[] = {
38135 (char *) "variant", NULL
38136 };
38137
38138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38139 if (obj0) {
38140 ecode1 = SWIG_AsVal_int(obj0, &val1);
38141 if (!SWIG_IsOK(ecode1)) {
38142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38143 }
38144 arg1 = static_cast< wxWindowVariant >(val1);
38145 }
38146 {
38147 if (!wxPyCheckForApp()) SWIG_fail;
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 result = wxWindow::GetClassDefaultAttributes(arg1);
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 wxWindow *arg1 = (wxWindow *) 0 ;
38163 wxColour *arg2 = 0 ;
38164 bool result;
38165 void *argp1 = 0 ;
38166 int res1 = 0 ;
38167 wxColour temp2 ;
38168 PyObject * obj0 = 0 ;
38169 PyObject * obj1 = 0 ;
38170 char * kwnames[] = {
38171 (char *) "self",(char *) "colour", NULL
38172 };
38173
38174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38176 if (!SWIG_IsOK(res1)) {
38177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38178 }
38179 arg1 = reinterpret_cast< wxWindow * >(argp1);
38180 {
38181 arg2 = &temp2;
38182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38183 }
38184 {
38185 PyThreadState* __tstate = wxPyBeginAllowThreads();
38186 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38187 wxPyEndAllowThreads(__tstate);
38188 if (PyErr_Occurred()) SWIG_fail;
38189 }
38190 {
38191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38192 }
38193 return resultobj;
38194 fail:
38195 return NULL;
38196 }
38197
38198
38199 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38200 PyObject *resultobj = 0;
38201 wxWindow *arg1 = (wxWindow *) 0 ;
38202 wxColour *arg2 = 0 ;
38203 void *argp1 = 0 ;
38204 int res1 = 0 ;
38205 wxColour temp2 ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "colour", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 arg2 = &temp2;
38220 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38221 }
38222 {
38223 PyThreadState* __tstate = wxPyBeginAllowThreads();
38224 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 resultobj = SWIG_Py_Void();
38229 return resultobj;
38230 fail:
38231 return NULL;
38232 }
38233
38234
38235 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38236 PyObject *resultobj = 0;
38237 wxWindow *arg1 = (wxWindow *) 0 ;
38238 wxColour *arg2 = 0 ;
38239 bool result;
38240 void *argp1 = 0 ;
38241 int res1 = 0 ;
38242 wxColour temp2 ;
38243 PyObject * obj0 = 0 ;
38244 PyObject * obj1 = 0 ;
38245 char * kwnames[] = {
38246 (char *) "self",(char *) "colour", NULL
38247 };
38248
38249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38253 }
38254 arg1 = reinterpret_cast< wxWindow * >(argp1);
38255 {
38256 arg2 = &temp2;
38257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38262 wxPyEndAllowThreads(__tstate);
38263 if (PyErr_Occurred()) SWIG_fail;
38264 }
38265 {
38266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38267 }
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 wxColour *arg2 = 0 ;
38278 void *argp1 = 0 ;
38279 int res1 = 0 ;
38280 wxColour temp2 ;
38281 PyObject * obj0 = 0 ;
38282 PyObject * obj1 = 0 ;
38283 char * kwnames[] = {
38284 (char *) "self",(char *) "colour", NULL
38285 };
38286
38287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38291 }
38292 arg1 = reinterpret_cast< wxWindow * >(argp1);
38293 {
38294 arg2 = &temp2;
38295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38296 }
38297 {
38298 PyThreadState* __tstate = wxPyBeginAllowThreads();
38299 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 resultobj = SWIG_Py_Void();
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38311 PyObject *resultobj = 0;
38312 wxWindow *arg1 = (wxWindow *) 0 ;
38313 wxColour result;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 PyObject *swig_obj[1] ;
38317
38318 if (!args) SWIG_fail;
38319 swig_obj[0] = args;
38320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38332 return resultobj;
38333 fail:
38334 return NULL;
38335 }
38336
38337
38338 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38339 PyObject *resultobj = 0;
38340 wxWindow *arg1 = (wxWindow *) 0 ;
38341 wxColour result;
38342 void *argp1 = 0 ;
38343 int res1 = 0 ;
38344 PyObject *swig_obj[1] ;
38345
38346 if (!args) SWIG_fail;
38347 swig_obj[0] = args;
38348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38349 if (!SWIG_IsOK(res1)) {
38350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38351 }
38352 arg1 = reinterpret_cast< wxWindow * >(argp1);
38353 {
38354 PyThreadState* __tstate = wxPyBeginAllowThreads();
38355 result = ((wxWindow const *)arg1)->GetForegroundColour();
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38367 PyObject *resultobj = 0;
38368 wxWindow *arg1 = (wxWindow *) 0 ;
38369 bool result;
38370 void *argp1 = 0 ;
38371 int res1 = 0 ;
38372 PyObject *swig_obj[1] ;
38373
38374 if (!args) SWIG_fail;
38375 swig_obj[0] = args;
38376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38377 if (!SWIG_IsOK(res1)) {
38378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38379 }
38380 arg1 = reinterpret_cast< wxWindow * >(argp1);
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38389 }
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38397 PyObject *resultobj = 0;
38398 wxWindow *arg1 = (wxWindow *) 0 ;
38399 bool result;
38400 void *argp1 = 0 ;
38401 int res1 = 0 ;
38402 PyObject *swig_obj[1] ;
38403
38404 if (!args) SWIG_fail;
38405 swig_obj[0] = args;
38406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38409 }
38410 arg1 = reinterpret_cast< wxWindow * >(argp1);
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 {
38418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38419 }
38420 return resultobj;
38421 fail:
38422 return NULL;
38423 }
38424
38425
38426 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38427 PyObject *resultobj = 0;
38428 wxWindow *arg1 = (wxWindow *) 0 ;
38429 wxBackgroundStyle arg2 ;
38430 bool result;
38431 void *argp1 = 0 ;
38432 int res1 = 0 ;
38433 int val2 ;
38434 int ecode2 = 0 ;
38435 PyObject * obj0 = 0 ;
38436 PyObject * obj1 = 0 ;
38437 char * kwnames[] = {
38438 (char *) "self",(char *) "style", NULL
38439 };
38440
38441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38443 if (!SWIG_IsOK(res1)) {
38444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38445 }
38446 arg1 = reinterpret_cast< wxWindow * >(argp1);
38447 ecode2 = SWIG_AsVal_int(obj1, &val2);
38448 if (!SWIG_IsOK(ecode2)) {
38449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38450 }
38451 arg2 = static_cast< wxBackgroundStyle >(val2);
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38468 PyObject *resultobj = 0;
38469 wxWindow *arg1 = (wxWindow *) 0 ;
38470 wxBackgroundStyle result;
38471 void *argp1 = 0 ;
38472 int res1 = 0 ;
38473 PyObject *swig_obj[1] ;
38474
38475 if (!args) SWIG_fail;
38476 swig_obj[0] = args;
38477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38480 }
38481 arg1 = reinterpret_cast< wxWindow * >(argp1);
38482 {
38483 PyThreadState* __tstate = wxPyBeginAllowThreads();
38484 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 resultobj = SWIG_From_int(static_cast< int >(result));
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38496 PyObject *resultobj = 0;
38497 wxWindow *arg1 = (wxWindow *) 0 ;
38498 bool result;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 PyObject *swig_obj[1] ;
38502
38503 if (!args) SWIG_fail;
38504 swig_obj[0] = args;
38505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38506 if (!SWIG_IsOK(res1)) {
38507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38508 }
38509 arg1 = reinterpret_cast< wxWindow * >(argp1);
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 result = (bool)(arg1)->HasTransparentBackground();
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 {
38517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38518 }
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj = 0;
38527 wxWindow *arg1 = (wxWindow *) 0 ;
38528 wxCursor *arg2 = 0 ;
38529 bool result;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 void *argp2 = 0 ;
38533 int res2 = 0 ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 char * kwnames[] = {
38537 (char *) "self",(char *) "cursor", NULL
38538 };
38539
38540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38542 if (!SWIG_IsOK(res1)) {
38543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38544 }
38545 arg1 = reinterpret_cast< wxWindow * >(argp1);
38546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38547 if (!SWIG_IsOK(res2)) {
38548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38549 }
38550 if (!argp2) {
38551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38552 }
38553 arg2 = reinterpret_cast< wxCursor * >(argp2);
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 {
38561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38562 }
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38570 PyObject *resultobj = 0;
38571 wxWindow *arg1 = (wxWindow *) 0 ;
38572 wxCursor result;
38573 void *argp1 = 0 ;
38574 int res1 = 0 ;
38575 PyObject *swig_obj[1] ;
38576
38577 if (!args) SWIG_fail;
38578 swig_obj[0] = args;
38579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38580 if (!SWIG_IsOK(res1)) {
38581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38582 }
38583 arg1 = reinterpret_cast< wxWindow * >(argp1);
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 result = (arg1)->GetCursor();
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38591 return resultobj;
38592 fail:
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj = 0;
38599 wxWindow *arg1 = (wxWindow *) 0 ;
38600 wxFont *arg2 = 0 ;
38601 bool result;
38602 void *argp1 = 0 ;
38603 int res1 = 0 ;
38604 void *argp2 = 0 ;
38605 int res2 = 0 ;
38606 PyObject * obj0 = 0 ;
38607 PyObject * obj1 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "font", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38619 if (!SWIG_IsOK(res2)) {
38620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38621 }
38622 if (!argp2) {
38623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38624 }
38625 arg2 = reinterpret_cast< wxFont * >(argp2);
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38629 wxPyEndAllowThreads(__tstate);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 }
38632 {
38633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38634 }
38635 return resultobj;
38636 fail:
38637 return NULL;
38638 }
38639
38640
38641 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38642 PyObject *resultobj = 0;
38643 wxWindow *arg1 = (wxWindow *) 0 ;
38644 wxFont *arg2 = 0 ;
38645 void *argp1 = 0 ;
38646 int res1 = 0 ;
38647 void *argp2 = 0 ;
38648 int res2 = 0 ;
38649 PyObject * obj0 = 0 ;
38650 PyObject * obj1 = 0 ;
38651 char * kwnames[] = {
38652 (char *) "self",(char *) "font", NULL
38653 };
38654
38655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38662 if (!SWIG_IsOK(res2)) {
38663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38664 }
38665 if (!argp2) {
38666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38667 }
38668 arg2 = reinterpret_cast< wxFont * >(argp2);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 (arg1)->SetOwnFont((wxFont const &)*arg2);
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 resultobj = SWIG_Py_Void();
38676 return resultobj;
38677 fail:
38678 return NULL;
38679 }
38680
38681
38682 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38683 PyObject *resultobj = 0;
38684 wxWindow *arg1 = (wxWindow *) 0 ;
38685 wxFont result;
38686 void *argp1 = 0 ;
38687 int res1 = 0 ;
38688 PyObject *swig_obj[1] ;
38689
38690 if (!args) SWIG_fail;
38691 swig_obj[0] = args;
38692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (arg1)->GetFont();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 wxCaret *arg2 = (wxCaret *) 0 ;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 int res2 = 0 ;
38717 PyObject * obj0 = 0 ;
38718 PyObject * obj1 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "caret", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38727 }
38728 arg1 = reinterpret_cast< wxWindow * >(argp1);
38729 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38730 if (!SWIG_IsOK(res2)) {
38731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38732 }
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 (arg1)->SetCaret(arg2);
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 resultobj = SWIG_Py_Void();
38740 return resultobj;
38741 fail:
38742 return NULL;
38743 }
38744
38745
38746 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38747 PyObject *resultobj = 0;
38748 wxWindow *arg1 = (wxWindow *) 0 ;
38749 wxCaret *result = 0 ;
38750 void *argp1 = 0 ;
38751 int res1 = 0 ;
38752 PyObject *swig_obj[1] ;
38753
38754 if (!args) SWIG_fail;
38755 swig_obj[0] = args;
38756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38757 if (!SWIG_IsOK(res1)) {
38758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38759 }
38760 arg1 = reinterpret_cast< wxWindow * >(argp1);
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 wxWindow *arg1 = (wxWindow *) 0 ;
38777 int result;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 PyObject *swig_obj[1] ;
38781
38782 if (!args) SWIG_fail;
38783 swig_obj[0] = args;
38784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38787 }
38788 arg1 = reinterpret_cast< wxWindow * >(argp1);
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 resultobj = SWIG_From_int(static_cast< int >(result));
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38803 PyObject *resultobj = 0;
38804 wxWindow *arg1 = (wxWindow *) 0 ;
38805 int result;
38806 void *argp1 = 0 ;
38807 int res1 = 0 ;
38808 PyObject *swig_obj[1] ;
38809
38810 if (!args) SWIG_fail;
38811 swig_obj[0] = args;
38812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38813 if (!SWIG_IsOK(res1)) {
38814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38815 }
38816 arg1 = reinterpret_cast< wxWindow * >(argp1);
38817 {
38818 PyThreadState* __tstate = wxPyBeginAllowThreads();
38819 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 resultobj = SWIG_From_int(static_cast< int >(result));
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj = 0;
38832 wxWindow *arg1 = (wxWindow *) 0 ;
38833 wxString *arg2 = 0 ;
38834 int *arg3 = (int *) 0 ;
38835 int *arg4 = (int *) 0 ;
38836 void *argp1 = 0 ;
38837 int res1 = 0 ;
38838 bool temp2 = false ;
38839 int temp3 ;
38840 int res3 = SWIG_TMPOBJ ;
38841 int temp4 ;
38842 int res4 = SWIG_TMPOBJ ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "self",(char *) "string", NULL
38847 };
38848
38849 arg3 = &temp3;
38850 arg4 = &temp4;
38851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38853 if (!SWIG_IsOK(res1)) {
38854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38855 }
38856 arg1 = reinterpret_cast< wxWindow * >(argp1);
38857 {
38858 arg2 = wxString_in_helper(obj1);
38859 if (arg2 == NULL) SWIG_fail;
38860 temp2 = true;
38861 }
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 resultobj = SWIG_Py_Void();
38869 if (SWIG_IsTmpObj(res3)) {
38870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38871 } else {
38872 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38874 }
38875 if (SWIG_IsTmpObj(res4)) {
38876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38877 } else {
38878 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38880 }
38881 {
38882 if (temp2)
38883 delete arg2;
38884 }
38885 return resultobj;
38886 fail:
38887 {
38888 if (temp2)
38889 delete arg2;
38890 }
38891 return NULL;
38892 }
38893
38894
38895 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38896 PyObject *resultobj = 0;
38897 wxWindow *arg1 = (wxWindow *) 0 ;
38898 wxString *arg2 = 0 ;
38899 int *arg3 = (int *) 0 ;
38900 int *arg4 = (int *) 0 ;
38901 int *arg5 = (int *) 0 ;
38902 int *arg6 = (int *) 0 ;
38903 wxFont *arg7 = (wxFont *) NULL ;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 bool temp2 = false ;
38907 int temp3 ;
38908 int res3 = SWIG_TMPOBJ ;
38909 int temp4 ;
38910 int res4 = SWIG_TMPOBJ ;
38911 int temp5 ;
38912 int res5 = SWIG_TMPOBJ ;
38913 int temp6 ;
38914 int res6 = SWIG_TMPOBJ ;
38915 void *argp7 = 0 ;
38916 int res7 = 0 ;
38917 PyObject * obj0 = 0 ;
38918 PyObject * obj1 = 0 ;
38919 PyObject * obj2 = 0 ;
38920 char * kwnames[] = {
38921 (char *) "self",(char *) "string",(char *) "font", NULL
38922 };
38923
38924 arg3 = &temp3;
38925 arg4 = &temp4;
38926 arg5 = &temp5;
38927 arg6 = &temp6;
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38932 }
38933 arg1 = reinterpret_cast< wxWindow * >(argp1);
38934 {
38935 arg2 = wxString_in_helper(obj1);
38936 if (arg2 == NULL) SWIG_fail;
38937 temp2 = true;
38938 }
38939 if (obj2) {
38940 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38941 if (!SWIG_IsOK(res7)) {
38942 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38943 }
38944 arg7 = reinterpret_cast< wxFont * >(argp7);
38945 }
38946 {
38947 PyThreadState* __tstate = wxPyBeginAllowThreads();
38948 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 resultobj = SWIG_Py_Void();
38953 if (SWIG_IsTmpObj(res3)) {
38954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38955 } else {
38956 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38958 }
38959 if (SWIG_IsTmpObj(res4)) {
38960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38961 } else {
38962 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38964 }
38965 if (SWIG_IsTmpObj(res5)) {
38966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38967 } else {
38968 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38970 }
38971 if (SWIG_IsTmpObj(res6)) {
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38973 } else {
38974 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38976 }
38977 {
38978 if (temp2)
38979 delete arg2;
38980 }
38981 return resultobj;
38982 fail:
38983 {
38984 if (temp2)
38985 delete arg2;
38986 }
38987 return NULL;
38988 }
38989
38990
38991 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38992 PyObject *resultobj = 0;
38993 wxWindow *arg1 = (wxWindow *) 0 ;
38994 int *arg2 = (int *) 0 ;
38995 int *arg3 = (int *) 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 int temp2 ;
38999 int res2 = 0 ;
39000 int temp3 ;
39001 int res3 = 0 ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 PyObject * obj2 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "self",(char *) "x",(char *) "y", NULL
39007 };
39008
39009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39011 if (!SWIG_IsOK(res1)) {
39012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39013 }
39014 arg1 = reinterpret_cast< wxWindow * >(argp1);
39015 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39016 int val;
39017 int ecode = SWIG_AsVal_int(obj1, &val);
39018 if (!SWIG_IsOK(ecode)) {
39019 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39020 }
39021 temp2 = static_cast< int >(val);
39022 arg2 = &temp2;
39023 res2 = SWIG_AddTmpMask(ecode);
39024 }
39025 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39026 int val;
39027 int ecode = SWIG_AsVal_int(obj2, &val);
39028 if (!SWIG_IsOK(ecode)) {
39029 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39030 }
39031 temp3 = static_cast< int >(val);
39032 arg3 = &temp3;
39033 res3 = SWIG_AddTmpMask(ecode);
39034 }
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 resultobj = SWIG_Py_Void();
39042 if (SWIG_IsTmpObj(res2)) {
39043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39044 } else {
39045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39047 }
39048 if (SWIG_IsTmpObj(res3)) {
39049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39050 } else {
39051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39053 }
39054 return resultobj;
39055 fail:
39056 return NULL;
39057 }
39058
39059
39060 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxWindow *arg1 = (wxWindow *) 0 ;
39063 int *arg2 = (int *) 0 ;
39064 int *arg3 = (int *) 0 ;
39065 void *argp1 = 0 ;
39066 int res1 = 0 ;
39067 int temp2 ;
39068 int res2 = 0 ;
39069 int temp3 ;
39070 int res3 = 0 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 PyObject * obj2 = 0 ;
39074 char * kwnames[] = {
39075 (char *) "self",(char *) "x",(char *) "y", NULL
39076 };
39077
39078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39080 if (!SWIG_IsOK(res1)) {
39081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39082 }
39083 arg1 = reinterpret_cast< wxWindow * >(argp1);
39084 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39085 int val;
39086 int ecode = SWIG_AsVal_int(obj1, &val);
39087 if (!SWIG_IsOK(ecode)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39089 }
39090 temp2 = static_cast< int >(val);
39091 arg2 = &temp2;
39092 res2 = SWIG_AddTmpMask(ecode);
39093 }
39094 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39095 int val;
39096 int ecode = SWIG_AsVal_int(obj2, &val);
39097 if (!SWIG_IsOK(ecode)) {
39098 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39099 }
39100 temp3 = static_cast< int >(val);
39101 arg3 = &temp3;
39102 res3 = SWIG_AddTmpMask(ecode);
39103 }
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 resultobj = SWIG_Py_Void();
39111 if (SWIG_IsTmpObj(res2)) {
39112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39113 } else {
39114 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39116 }
39117 if (SWIG_IsTmpObj(res3)) {
39118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39119 } else {
39120 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39122 }
39123 return resultobj;
39124 fail:
39125 return NULL;
39126 }
39127
39128
39129 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39130 PyObject *resultobj = 0;
39131 wxWindow *arg1 = (wxWindow *) 0 ;
39132 wxPoint *arg2 = 0 ;
39133 wxPoint result;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 wxPoint temp2 ;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 char * kwnames[] = {
39140 (char *) "self",(char *) "pt", NULL
39141 };
39142
39143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39147 }
39148 arg1 = reinterpret_cast< wxWindow * >(argp1);
39149 {
39150 arg2 = &temp2;
39151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39152 }
39153 {
39154 PyThreadState* __tstate = wxPyBeginAllowThreads();
39155 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39156 wxPyEndAllowThreads(__tstate);
39157 if (PyErr_Occurred()) SWIG_fail;
39158 }
39159 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39160 return resultobj;
39161 fail:
39162 return NULL;
39163 }
39164
39165
39166 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39167 PyObject *resultobj = 0;
39168 wxWindow *arg1 = (wxWindow *) 0 ;
39169 wxPoint *arg2 = 0 ;
39170 wxPoint result;
39171 void *argp1 = 0 ;
39172 int res1 = 0 ;
39173 wxPoint temp2 ;
39174 PyObject * obj0 = 0 ;
39175 PyObject * obj1 = 0 ;
39176 char * kwnames[] = {
39177 (char *) "self",(char *) "pt", NULL
39178 };
39179
39180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39182 if (!SWIG_IsOK(res1)) {
39183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39184 }
39185 arg1 = reinterpret_cast< wxWindow * >(argp1);
39186 {
39187 arg2 = &temp2;
39188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39189 }
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39193 wxPyEndAllowThreads(__tstate);
39194 if (PyErr_Occurred()) SWIG_fail;
39195 }
39196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39197 return resultobj;
39198 fail:
39199 return NULL;
39200 }
39201
39202
39203 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj = 0;
39205 wxWindow *arg1 = (wxWindow *) 0 ;
39206 int arg2 ;
39207 int arg3 ;
39208 wxHitTest result;
39209 void *argp1 = 0 ;
39210 int res1 = 0 ;
39211 int val2 ;
39212 int ecode2 = 0 ;
39213 int val3 ;
39214 int ecode3 = 0 ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 PyObject * obj2 = 0 ;
39218 char * kwnames[] = {
39219 (char *) "self",(char *) "x",(char *) "y", NULL
39220 };
39221
39222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39226 }
39227 arg1 = reinterpret_cast< wxWindow * >(argp1);
39228 ecode2 = SWIG_AsVal_int(obj1, &val2);
39229 if (!SWIG_IsOK(ecode2)) {
39230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39231 }
39232 arg2 = static_cast< int >(val2);
39233 ecode3 = SWIG_AsVal_int(obj2, &val3);
39234 if (!SWIG_IsOK(ecode3)) {
39235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39236 }
39237 arg3 = static_cast< int >(val3);
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 resultobj = SWIG_From_int(static_cast< int >(result));
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj = 0;
39253 wxWindow *arg1 = (wxWindow *) 0 ;
39254 wxPoint *arg2 = 0 ;
39255 wxHitTest result;
39256 void *argp1 = 0 ;
39257 int res1 = 0 ;
39258 wxPoint temp2 ;
39259 PyObject * obj0 = 0 ;
39260 PyObject * obj1 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "pt", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39269 }
39270 arg1 = reinterpret_cast< wxWindow * >(argp1);
39271 {
39272 arg2 = &temp2;
39273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39274 }
39275 {
39276 PyThreadState* __tstate = wxPyBeginAllowThreads();
39277 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39278 wxPyEndAllowThreads(__tstate);
39279 if (PyErr_Occurred()) SWIG_fail;
39280 }
39281 resultobj = SWIG_From_int(static_cast< int >(result));
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39289 PyObject *resultobj = 0;
39290 wxWindow *arg1 = (wxWindow *) 0 ;
39291 long arg2 ;
39292 wxBorder result;
39293 void *argp1 = 0 ;
39294 int res1 = 0 ;
39295 long val2 ;
39296 int ecode2 = 0 ;
39297
39298 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39302 }
39303 arg1 = reinterpret_cast< wxWindow * >(argp1);
39304 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39305 if (!SWIG_IsOK(ecode2)) {
39306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39307 }
39308 arg2 = static_cast< long >(val2);
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 resultobj = SWIG_From_int(static_cast< int >(result));
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39323 PyObject *resultobj = 0;
39324 wxWindow *arg1 = (wxWindow *) 0 ;
39325 wxBorder result;
39326 void *argp1 = 0 ;
39327 int res1 = 0 ;
39328
39329 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39331 if (!SWIG_IsOK(res1)) {
39332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39333 }
39334 arg1 = reinterpret_cast< wxWindow * >(argp1);
39335 {
39336 PyThreadState* __tstate = wxPyBeginAllowThreads();
39337 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 resultobj = SWIG_From_int(static_cast< int >(result));
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39349 int argc;
39350 PyObject *argv[3];
39351
39352 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39353 --argc;
39354 if (argc == 1) {
39355 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39356 }
39357 if (argc == 2) {
39358 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39359 }
39360
39361 fail:
39362 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39363 return NULL;
39364 }
39365
39366
39367 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39368 PyObject *resultobj = 0;
39369 wxWindow *arg1 = (wxWindow *) 0 ;
39370 long arg2 = (long) wxUPDATE_UI_NONE ;
39371 void *argp1 = 0 ;
39372 int res1 = 0 ;
39373 long val2 ;
39374 int ecode2 = 0 ;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "flags", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39385 }
39386 arg1 = reinterpret_cast< wxWindow * >(argp1);
39387 if (obj1) {
39388 ecode2 = SWIG_AsVal_long(obj1, &val2);
39389 if (!SWIG_IsOK(ecode2)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39391 }
39392 arg2 = static_cast< long >(val2);
39393 }
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 (arg1)->UpdateWindowUI(arg2);
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 resultobj = SWIG_Py_Void();
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj = 0;
39409 wxWindow *arg1 = (wxWindow *) 0 ;
39410 wxMenu *arg2 = (wxMenu *) 0 ;
39411 int arg3 = (int) -1 ;
39412 int arg4 = (int) -1 ;
39413 bool result;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 void *argp2 = 0 ;
39417 int res2 = 0 ;
39418 int val3 ;
39419 int ecode3 = 0 ;
39420 int val4 ;
39421 int ecode4 = 0 ;
39422 PyObject * obj0 = 0 ;
39423 PyObject * obj1 = 0 ;
39424 PyObject * obj2 = 0 ;
39425 PyObject * obj3 = 0 ;
39426 char * kwnames[] = {
39427 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39428 };
39429
39430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39432 if (!SWIG_IsOK(res1)) {
39433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39434 }
39435 arg1 = reinterpret_cast< wxWindow * >(argp1);
39436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res2)) {
39438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39439 }
39440 arg2 = reinterpret_cast< wxMenu * >(argp2);
39441 if (obj2) {
39442 ecode3 = SWIG_AsVal_int(obj2, &val3);
39443 if (!SWIG_IsOK(ecode3)) {
39444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39445 }
39446 arg3 = static_cast< int >(val3);
39447 }
39448 if (obj3) {
39449 ecode4 = SWIG_AsVal_int(obj3, &val4);
39450 if (!SWIG_IsOK(ecode4)) {
39451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39452 }
39453 arg4 = static_cast< int >(val4);
39454 }
39455 {
39456 PyThreadState* __tstate = wxPyBeginAllowThreads();
39457 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39458 wxPyEndAllowThreads(__tstate);
39459 if (PyErr_Occurred()) SWIG_fail;
39460 }
39461 {
39462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39463 }
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39471 PyObject *resultobj = 0;
39472 wxWindow *arg1 = (wxWindow *) 0 ;
39473 wxMenu *arg2 = (wxMenu *) 0 ;
39474 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39475 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39476 bool result;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 void *argp2 = 0 ;
39480 int res2 = 0 ;
39481 wxPoint temp3 ;
39482 PyObject * obj0 = 0 ;
39483 PyObject * obj1 = 0 ;
39484 PyObject * obj2 = 0 ;
39485 char * kwnames[] = {
39486 (char *) "self",(char *) "menu",(char *) "pos", NULL
39487 };
39488
39489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39493 }
39494 arg1 = reinterpret_cast< wxWindow * >(argp1);
39495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39496 if (!SWIG_IsOK(res2)) {
39497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39498 }
39499 arg2 = reinterpret_cast< wxMenu * >(argp2);
39500 if (obj2) {
39501 {
39502 arg3 = &temp3;
39503 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39504 }
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39522 PyObject *resultobj = 0;
39523 wxWindow *arg1 = (wxWindow *) 0 ;
39524 bool result;
39525 void *argp1 = 0 ;
39526 int res1 = 0 ;
39527 PyObject *swig_obj[1] ;
39528
39529 if (!args) SWIG_fail;
39530 swig_obj[0] = args;
39531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39532 if (!SWIG_IsOK(res1)) {
39533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39534 }
39535 arg1 = reinterpret_cast< wxWindow * >(argp1);
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39539 wxPyEndAllowThreads(__tstate);
39540 if (PyErr_Occurred()) SWIG_fail;
39541 }
39542 {
39543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39544 }
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39552 PyObject *resultobj = 0;
39553 wxWindow *arg1 = (wxWindow *) 0 ;
39554 long result;
39555 void *argp1 = 0 ;
39556 int res1 = 0 ;
39557 PyObject *swig_obj[1] ;
39558
39559 if (!args) SWIG_fail;
39560 swig_obj[0] = args;
39561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39562 if (!SWIG_IsOK(res1)) {
39563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39564 }
39565 arg1 = reinterpret_cast< wxWindow * >(argp1);
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (long)wxWindow_GetHandle(arg1);
39569 wxPyEndAllowThreads(__tstate);
39570 if (PyErr_Occurred()) SWIG_fail;
39571 }
39572 resultobj = SWIG_From_long(static_cast< long >(result));
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj = 0;
39581 wxWindow *arg1 = (wxWindow *) 0 ;
39582 long arg2 ;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 long val2 ;
39586 int ecode2 = 0 ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "handle", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39597 }
39598 arg1 = reinterpret_cast< wxWindow * >(argp1);
39599 ecode2 = SWIG_AsVal_long(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39602 }
39603 arg2 = static_cast< long >(val2);
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 wxWindow_AssociateHandle(arg1,arg2);
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 resultobj = SWIG_Py_Void();
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39618 PyObject *resultobj = 0;
39619 wxWindow *arg1 = (wxWindow *) 0 ;
39620 void *argp1 = 0 ;
39621 int res1 = 0 ;
39622 PyObject *swig_obj[1] ;
39623
39624 if (!args) SWIG_fail;
39625 swig_obj[0] = args;
39626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39627 if (!SWIG_IsOK(res1)) {
39628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39629 }
39630 arg1 = reinterpret_cast< wxWindow * >(argp1);
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 (arg1)->DissociateHandle();
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 resultobj = SWIG_Py_Void();
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj = 0;
39646 wxWindow *arg1 = (wxWindow *) 0 ;
39647 int arg2 ;
39648 bool result;
39649 void *argp1 = 0 ;
39650 int res1 = 0 ;
39651 int val2 ;
39652 int ecode2 = 0 ;
39653 PyObject * obj0 = 0 ;
39654 PyObject * obj1 = 0 ;
39655 char * kwnames[] = {
39656 (char *) "self",(char *) "orient", NULL
39657 };
39658
39659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39661 if (!SWIG_IsOK(res1)) {
39662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39663 }
39664 arg1 = reinterpret_cast< wxWindow * >(argp1);
39665 ecode2 = SWIG_AsVal_int(obj1, &val2);
39666 if (!SWIG_IsOK(ecode2)) {
39667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39668 }
39669 arg2 = static_cast< int >(val2);
39670 {
39671 PyThreadState* __tstate = wxPyBeginAllowThreads();
39672 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39673 wxPyEndAllowThreads(__tstate);
39674 if (PyErr_Occurred()) SWIG_fail;
39675 }
39676 {
39677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39678 }
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = 0;
39687 wxWindow *arg1 = (wxWindow *) 0 ;
39688 int arg2 ;
39689 int arg3 ;
39690 int arg4 ;
39691 int arg5 ;
39692 bool arg6 = (bool) true ;
39693 void *argp1 = 0 ;
39694 int res1 = 0 ;
39695 int val2 ;
39696 int ecode2 = 0 ;
39697 int val3 ;
39698 int ecode3 = 0 ;
39699 int val4 ;
39700 int ecode4 = 0 ;
39701 int val5 ;
39702 int ecode5 = 0 ;
39703 bool val6 ;
39704 int ecode6 = 0 ;
39705 PyObject * obj0 = 0 ;
39706 PyObject * obj1 = 0 ;
39707 PyObject * obj2 = 0 ;
39708 PyObject * obj3 = 0 ;
39709 PyObject * obj4 = 0 ;
39710 PyObject * obj5 = 0 ;
39711 char * kwnames[] = {
39712 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39713 };
39714
39715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39717 if (!SWIG_IsOK(res1)) {
39718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39719 }
39720 arg1 = reinterpret_cast< wxWindow * >(argp1);
39721 ecode2 = SWIG_AsVal_int(obj1, &val2);
39722 if (!SWIG_IsOK(ecode2)) {
39723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39724 }
39725 arg2 = static_cast< int >(val2);
39726 ecode3 = SWIG_AsVal_int(obj2, &val3);
39727 if (!SWIG_IsOK(ecode3)) {
39728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39729 }
39730 arg3 = static_cast< int >(val3);
39731 ecode4 = SWIG_AsVal_int(obj3, &val4);
39732 if (!SWIG_IsOK(ecode4)) {
39733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39734 }
39735 arg4 = static_cast< int >(val4);
39736 ecode5 = SWIG_AsVal_int(obj4, &val5);
39737 if (!SWIG_IsOK(ecode5)) {
39738 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39739 }
39740 arg5 = static_cast< int >(val5);
39741 if (obj5) {
39742 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39743 if (!SWIG_IsOK(ecode6)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39745 }
39746 arg6 = static_cast< bool >(val6);
39747 }
39748 {
39749 PyThreadState* __tstate = wxPyBeginAllowThreads();
39750 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39751 wxPyEndAllowThreads(__tstate);
39752 if (PyErr_Occurred()) SWIG_fail;
39753 }
39754 resultobj = SWIG_Py_Void();
39755 return resultobj;
39756 fail:
39757 return NULL;
39758 }
39759
39760
39761 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39762 PyObject *resultobj = 0;
39763 wxWindow *arg1 = (wxWindow *) 0 ;
39764 int arg2 ;
39765 int arg3 ;
39766 bool arg4 = (bool) true ;
39767 void *argp1 = 0 ;
39768 int res1 = 0 ;
39769 int val2 ;
39770 int ecode2 = 0 ;
39771 int val3 ;
39772 int ecode3 = 0 ;
39773 bool val4 ;
39774 int ecode4 = 0 ;
39775 PyObject * obj0 = 0 ;
39776 PyObject * obj1 = 0 ;
39777 PyObject * obj2 = 0 ;
39778 PyObject * obj3 = 0 ;
39779 char * kwnames[] = {
39780 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39781 };
39782
39783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39785 if (!SWIG_IsOK(res1)) {
39786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39787 }
39788 arg1 = reinterpret_cast< wxWindow * >(argp1);
39789 ecode2 = SWIG_AsVal_int(obj1, &val2);
39790 if (!SWIG_IsOK(ecode2)) {
39791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39792 }
39793 arg2 = static_cast< int >(val2);
39794 ecode3 = SWIG_AsVal_int(obj2, &val3);
39795 if (!SWIG_IsOK(ecode3)) {
39796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39797 }
39798 arg3 = static_cast< int >(val3);
39799 if (obj3) {
39800 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39801 if (!SWIG_IsOK(ecode4)) {
39802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39803 }
39804 arg4 = static_cast< bool >(val4);
39805 }
39806 {
39807 PyThreadState* __tstate = wxPyBeginAllowThreads();
39808 (arg1)->SetScrollPos(arg2,arg3,arg4);
39809 wxPyEndAllowThreads(__tstate);
39810 if (PyErr_Occurred()) SWIG_fail;
39811 }
39812 resultobj = SWIG_Py_Void();
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39820 PyObject *resultobj = 0;
39821 wxWindow *arg1 = (wxWindow *) 0 ;
39822 int arg2 ;
39823 int result;
39824 void *argp1 = 0 ;
39825 int res1 = 0 ;
39826 int val2 ;
39827 int ecode2 = 0 ;
39828 PyObject * obj0 = 0 ;
39829 PyObject * obj1 = 0 ;
39830 char * kwnames[] = {
39831 (char *) "self",(char *) "orientation", NULL
39832 };
39833
39834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39836 if (!SWIG_IsOK(res1)) {
39837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39838 }
39839 arg1 = reinterpret_cast< wxWindow * >(argp1);
39840 ecode2 = SWIG_AsVal_int(obj1, &val2);
39841 if (!SWIG_IsOK(ecode2)) {
39842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39843 }
39844 arg2 = static_cast< int >(val2);
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 resultobj = SWIG_From_int(static_cast< int >(result));
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj = 0;
39860 wxWindow *arg1 = (wxWindow *) 0 ;
39861 int arg2 ;
39862 int result;
39863 void *argp1 = 0 ;
39864 int res1 = 0 ;
39865 int val2 ;
39866 int ecode2 = 0 ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 char * kwnames[] = {
39870 (char *) "self",(char *) "orientation", NULL
39871 };
39872
39873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39877 }
39878 arg1 = reinterpret_cast< wxWindow * >(argp1);
39879 ecode2 = SWIG_AsVal_int(obj1, &val2);
39880 if (!SWIG_IsOK(ecode2)) {
39881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39882 }
39883 arg2 = static_cast< int >(val2);
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 resultobj = SWIG_From_int(static_cast< int >(result));
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39898 PyObject *resultobj = 0;
39899 wxWindow *arg1 = (wxWindow *) 0 ;
39900 int arg2 ;
39901 int result;
39902 void *argp1 = 0 ;
39903 int res1 = 0 ;
39904 int val2 ;
39905 int ecode2 = 0 ;
39906 PyObject * obj0 = 0 ;
39907 PyObject * obj1 = 0 ;
39908 char * kwnames[] = {
39909 (char *) "self",(char *) "orientation", NULL
39910 };
39911
39912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39914 if (!SWIG_IsOK(res1)) {
39915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39916 }
39917 arg1 = reinterpret_cast< wxWindow * >(argp1);
39918 ecode2 = SWIG_AsVal_int(obj1, &val2);
39919 if (!SWIG_IsOK(ecode2)) {
39920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39921 }
39922 arg2 = static_cast< int >(val2);
39923 {
39924 PyThreadState* __tstate = wxPyBeginAllowThreads();
39925 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39926 wxPyEndAllowThreads(__tstate);
39927 if (PyErr_Occurred()) SWIG_fail;
39928 }
39929 resultobj = SWIG_From_int(static_cast< int >(result));
39930 return resultobj;
39931 fail:
39932 return NULL;
39933 }
39934
39935
39936 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39937 PyObject *resultobj = 0;
39938 wxWindow *arg1 = (wxWindow *) 0 ;
39939 int arg2 ;
39940 int arg3 ;
39941 wxRect *arg4 = (wxRect *) NULL ;
39942 void *argp1 = 0 ;
39943 int res1 = 0 ;
39944 int val2 ;
39945 int ecode2 = 0 ;
39946 int val3 ;
39947 int ecode3 = 0 ;
39948 void *argp4 = 0 ;
39949 int res4 = 0 ;
39950 PyObject * obj0 = 0 ;
39951 PyObject * obj1 = 0 ;
39952 PyObject * obj2 = 0 ;
39953 PyObject * obj3 = 0 ;
39954 char * kwnames[] = {
39955 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39956 };
39957
39958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39960 if (!SWIG_IsOK(res1)) {
39961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39962 }
39963 arg1 = reinterpret_cast< wxWindow * >(argp1);
39964 ecode2 = SWIG_AsVal_int(obj1, &val2);
39965 if (!SWIG_IsOK(ecode2)) {
39966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39967 }
39968 arg2 = static_cast< int >(val2);
39969 ecode3 = SWIG_AsVal_int(obj2, &val3);
39970 if (!SWIG_IsOK(ecode3)) {
39971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39972 }
39973 arg3 = static_cast< int >(val3);
39974 if (obj3) {
39975 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39976 if (!SWIG_IsOK(res4)) {
39977 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39978 }
39979 arg4 = reinterpret_cast< wxRect * >(argp4);
39980 }
39981 {
39982 PyThreadState* __tstate = wxPyBeginAllowThreads();
39983 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 resultobj = SWIG_Py_Void();
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj = 0;
39996 wxWindow *arg1 = (wxWindow *) 0 ;
39997 int arg2 ;
39998 bool result;
39999 void *argp1 = 0 ;
40000 int res1 = 0 ;
40001 int val2 ;
40002 int ecode2 = 0 ;
40003 PyObject * obj0 = 0 ;
40004 PyObject * obj1 = 0 ;
40005 char * kwnames[] = {
40006 (char *) "self",(char *) "lines", NULL
40007 };
40008
40009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40011 if (!SWIG_IsOK(res1)) {
40012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40013 }
40014 arg1 = reinterpret_cast< wxWindow * >(argp1);
40015 ecode2 = SWIG_AsVal_int(obj1, &val2);
40016 if (!SWIG_IsOK(ecode2)) {
40017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40018 }
40019 arg2 = static_cast< int >(val2);
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 result = (bool)(arg1)->ScrollLines(arg2);
40023 wxPyEndAllowThreads(__tstate);
40024 if (PyErr_Occurred()) SWIG_fail;
40025 }
40026 {
40027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40028 }
40029 return resultobj;
40030 fail:
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40036 PyObject *resultobj = 0;
40037 wxWindow *arg1 = (wxWindow *) 0 ;
40038 int arg2 ;
40039 bool 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 *) "pages", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40054 }
40055 arg1 = reinterpret_cast< wxWindow * >(argp1);
40056 ecode2 = SWIG_AsVal_int(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40059 }
40060 arg2 = static_cast< int >(val2);
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = (bool)(arg1)->ScrollPages(arg2);
40064 wxPyEndAllowThreads(__tstate);
40065 if (PyErr_Occurred()) SWIG_fail;
40066 }
40067 {
40068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40069 }
40070 return resultobj;
40071 fail:
40072 return NULL;
40073 }
40074
40075
40076 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40077 PyObject *resultobj = 0;
40078 wxWindow *arg1 = (wxWindow *) 0 ;
40079 bool result;
40080 void *argp1 = 0 ;
40081 int res1 = 0 ;
40082 PyObject *swig_obj[1] ;
40083
40084 if (!args) SWIG_fail;
40085 swig_obj[0] = args;
40086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40087 if (!SWIG_IsOK(res1)) {
40088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40089 }
40090 arg1 = reinterpret_cast< wxWindow * >(argp1);
40091 {
40092 PyThreadState* __tstate = wxPyBeginAllowThreads();
40093 result = (bool)(arg1)->LineUp();
40094 wxPyEndAllowThreads(__tstate);
40095 if (PyErr_Occurred()) SWIG_fail;
40096 }
40097 {
40098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40099 }
40100 return resultobj;
40101 fail:
40102 return NULL;
40103 }
40104
40105
40106 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40107 PyObject *resultobj = 0;
40108 wxWindow *arg1 = (wxWindow *) 0 ;
40109 bool result;
40110 void *argp1 = 0 ;
40111 int res1 = 0 ;
40112 PyObject *swig_obj[1] ;
40113
40114 if (!args) SWIG_fail;
40115 swig_obj[0] = args;
40116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40117 if (!SWIG_IsOK(res1)) {
40118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40119 }
40120 arg1 = reinterpret_cast< wxWindow * >(argp1);
40121 {
40122 PyThreadState* __tstate = wxPyBeginAllowThreads();
40123 result = (bool)(arg1)->LineDown();
40124 wxPyEndAllowThreads(__tstate);
40125 if (PyErr_Occurred()) SWIG_fail;
40126 }
40127 {
40128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40129 }
40130 return resultobj;
40131 fail:
40132 return NULL;
40133 }
40134
40135
40136 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40137 PyObject *resultobj = 0;
40138 wxWindow *arg1 = (wxWindow *) 0 ;
40139 bool result;
40140 void *argp1 = 0 ;
40141 int res1 = 0 ;
40142 PyObject *swig_obj[1] ;
40143
40144 if (!args) SWIG_fail;
40145 swig_obj[0] = args;
40146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40147 if (!SWIG_IsOK(res1)) {
40148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40149 }
40150 arg1 = reinterpret_cast< wxWindow * >(argp1);
40151 {
40152 PyThreadState* __tstate = wxPyBeginAllowThreads();
40153 result = (bool)(arg1)->PageUp();
40154 wxPyEndAllowThreads(__tstate);
40155 if (PyErr_Occurred()) SWIG_fail;
40156 }
40157 {
40158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40159 }
40160 return resultobj;
40161 fail:
40162 return NULL;
40163 }
40164
40165
40166 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40167 PyObject *resultobj = 0;
40168 wxWindow *arg1 = (wxWindow *) 0 ;
40169 bool result;
40170 void *argp1 = 0 ;
40171 int res1 = 0 ;
40172 PyObject *swig_obj[1] ;
40173
40174 if (!args) SWIG_fail;
40175 swig_obj[0] = args;
40176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40177 if (!SWIG_IsOK(res1)) {
40178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40179 }
40180 arg1 = reinterpret_cast< wxWindow * >(argp1);
40181 {
40182 PyThreadState* __tstate = wxPyBeginAllowThreads();
40183 result = (bool)(arg1)->PageDown();
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 {
40188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40189 }
40190 return resultobj;
40191 fail:
40192 return NULL;
40193 }
40194
40195
40196 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40197 PyObject *resultobj = 0;
40198 wxWindow *arg1 = (wxWindow *) 0 ;
40199 wxString *arg2 = 0 ;
40200 void *argp1 = 0 ;
40201 int res1 = 0 ;
40202 bool temp2 = false ;
40203 PyObject * obj0 = 0 ;
40204 PyObject * obj1 = 0 ;
40205 char * kwnames[] = {
40206 (char *) "self",(char *) "text", NULL
40207 };
40208
40209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40211 if (!SWIG_IsOK(res1)) {
40212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40213 }
40214 arg1 = reinterpret_cast< wxWindow * >(argp1);
40215 {
40216 arg2 = wxString_in_helper(obj1);
40217 if (arg2 == NULL) SWIG_fail;
40218 temp2 = true;
40219 }
40220 {
40221 PyThreadState* __tstate = wxPyBeginAllowThreads();
40222 (arg1)->SetHelpText((wxString const &)*arg2);
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 resultobj = SWIG_Py_Void();
40227 {
40228 if (temp2)
40229 delete arg2;
40230 }
40231 return resultobj;
40232 fail:
40233 {
40234 if (temp2)
40235 delete arg2;
40236 }
40237 return NULL;
40238 }
40239
40240
40241 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40242 PyObject *resultobj = 0;
40243 wxWindow *arg1 = (wxWindow *) 0 ;
40244 wxString *arg2 = 0 ;
40245 void *argp1 = 0 ;
40246 int res1 = 0 ;
40247 bool temp2 = false ;
40248 PyObject * obj0 = 0 ;
40249 PyObject * obj1 = 0 ;
40250 char * kwnames[] = {
40251 (char *) "self",(char *) "text", NULL
40252 };
40253
40254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40256 if (!SWIG_IsOK(res1)) {
40257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40258 }
40259 arg1 = reinterpret_cast< wxWindow * >(argp1);
40260 {
40261 arg2 = wxString_in_helper(obj1);
40262 if (arg2 == NULL) SWIG_fail;
40263 temp2 = true;
40264 }
40265 {
40266 PyThreadState* __tstate = wxPyBeginAllowThreads();
40267 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40268 wxPyEndAllowThreads(__tstate);
40269 if (PyErr_Occurred()) SWIG_fail;
40270 }
40271 resultobj = SWIG_Py_Void();
40272 {
40273 if (temp2)
40274 delete arg2;
40275 }
40276 return resultobj;
40277 fail:
40278 {
40279 if (temp2)
40280 delete arg2;
40281 }
40282 return NULL;
40283 }
40284
40285
40286 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40287 PyObject *resultobj = 0;
40288 wxWindow *arg1 = (wxWindow *) 0 ;
40289 wxPoint *arg2 = 0 ;
40290 wxHelpEvent::Origin arg3 ;
40291 wxString result;
40292 void *argp1 = 0 ;
40293 int res1 = 0 ;
40294 wxPoint temp2 ;
40295 void *argp3 ;
40296 int res3 = 0 ;
40297 PyObject * obj0 = 0 ;
40298 PyObject * obj1 = 0 ;
40299 PyObject * obj2 = 0 ;
40300 char * kwnames[] = {
40301 (char *) "self",(char *) "pt",(char *) "origin", NULL
40302 };
40303
40304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40306 if (!SWIG_IsOK(res1)) {
40307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40308 }
40309 arg1 = reinterpret_cast< wxWindow * >(argp1);
40310 {
40311 arg2 = &temp2;
40312 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40313 }
40314 {
40315 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40316 if (!SWIG_IsOK(res3)) {
40317 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40318 }
40319 if (!argp3) {
40320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40321 } else {
40322 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40323 arg3 = *temp;
40324 if (SWIG_IsNewObj(res3)) delete temp;
40325 }
40326 }
40327 {
40328 PyThreadState* __tstate = wxPyBeginAllowThreads();
40329 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40330 wxPyEndAllowThreads(__tstate);
40331 if (PyErr_Occurred()) SWIG_fail;
40332 }
40333 {
40334 #if wxUSE_UNICODE
40335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40336 #else
40337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40338 #endif
40339 }
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40347 PyObject *resultobj = 0;
40348 wxWindow *arg1 = (wxWindow *) 0 ;
40349 wxString result;
40350 void *argp1 = 0 ;
40351 int res1 = 0 ;
40352 PyObject *swig_obj[1] ;
40353
40354 if (!args) SWIG_fail;
40355 swig_obj[0] = args;
40356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40357 if (!SWIG_IsOK(res1)) {
40358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40359 }
40360 arg1 = reinterpret_cast< wxWindow * >(argp1);
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = ((wxWindow const *)arg1)->GetHelpText();
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 #if wxUSE_UNICODE
40369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40370 #else
40371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40372 #endif
40373 }
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj = 0;
40382 wxWindow *arg1 = (wxWindow *) 0 ;
40383 wxString *arg2 = 0 ;
40384 void *argp1 = 0 ;
40385 int res1 = 0 ;
40386 bool temp2 = false ;
40387 PyObject * obj0 = 0 ;
40388 PyObject * obj1 = 0 ;
40389 char * kwnames[] = {
40390 (char *) "self",(char *) "tip", NULL
40391 };
40392
40393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40395 if (!SWIG_IsOK(res1)) {
40396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40397 }
40398 arg1 = reinterpret_cast< wxWindow * >(argp1);
40399 {
40400 arg2 = wxString_in_helper(obj1);
40401 if (arg2 == NULL) SWIG_fail;
40402 temp2 = true;
40403 }
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 (arg1)->SetToolTip((wxString const &)*arg2);
40407 wxPyEndAllowThreads(__tstate);
40408 if (PyErr_Occurred()) SWIG_fail;
40409 }
40410 resultobj = SWIG_Py_Void();
40411 {
40412 if (temp2)
40413 delete arg2;
40414 }
40415 return resultobj;
40416 fail:
40417 {
40418 if (temp2)
40419 delete arg2;
40420 }
40421 return NULL;
40422 }
40423
40424
40425 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj = 0;
40427 wxWindow *arg1 = (wxWindow *) 0 ;
40428 wxToolTip *arg2 = (wxToolTip *) 0 ;
40429 void *argp1 = 0 ;
40430 int res1 = 0 ;
40431 int res2 = 0 ;
40432 PyObject * obj0 = 0 ;
40433 PyObject * obj1 = 0 ;
40434 char * kwnames[] = {
40435 (char *) "self",(char *) "tip", NULL
40436 };
40437
40438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40440 if (!SWIG_IsOK(res1)) {
40441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40442 }
40443 arg1 = reinterpret_cast< wxWindow * >(argp1);
40444 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40445 if (!SWIG_IsOK(res2)) {
40446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40447 }
40448 {
40449 PyThreadState* __tstate = wxPyBeginAllowThreads();
40450 (arg1)->SetToolTip(arg2);
40451 wxPyEndAllowThreads(__tstate);
40452 if (PyErr_Occurred()) SWIG_fail;
40453 }
40454 resultobj = SWIG_Py_Void();
40455 return resultobj;
40456 fail:
40457 return NULL;
40458 }
40459
40460
40461 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40462 PyObject *resultobj = 0;
40463 wxWindow *arg1 = (wxWindow *) 0 ;
40464 wxToolTip *result = 0 ;
40465 void *argp1 = 0 ;
40466 int res1 = 0 ;
40467 PyObject *swig_obj[1] ;
40468
40469 if (!args) SWIG_fail;
40470 swig_obj[0] = args;
40471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40472 if (!SWIG_IsOK(res1)) {
40473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40474 }
40475 arg1 = reinterpret_cast< wxWindow * >(argp1);
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 {
40483 resultobj = wxPyMake_wxObject(result, (bool)0);
40484 }
40485 return resultobj;
40486 fail:
40487 return NULL;
40488 }
40489
40490
40491 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40492 PyObject *resultobj = 0;
40493 wxWindow *arg1 = (wxWindow *) 0 ;
40494 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40495 void *argp1 = 0 ;
40496 int res1 = 0 ;
40497 int res2 = 0 ;
40498 PyObject * obj0 = 0 ;
40499 PyObject * obj1 = 0 ;
40500 char * kwnames[] = {
40501 (char *) "self",(char *) "dropTarget", NULL
40502 };
40503
40504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40508 }
40509 arg1 = reinterpret_cast< wxWindow * >(argp1);
40510 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40511 if (!SWIG_IsOK(res2)) {
40512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40513 }
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 (arg1)->SetDropTarget(arg2);
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 resultobj = SWIG_Py_Void();
40521 return resultobj;
40522 fail:
40523 return NULL;
40524 }
40525
40526
40527 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40528 PyObject *resultobj = 0;
40529 wxWindow *arg1 = (wxWindow *) 0 ;
40530 wxPyDropTarget *result = 0 ;
40531 void *argp1 = 0 ;
40532 int res1 = 0 ;
40533 PyObject *swig_obj[1] ;
40534
40535 if (!args) SWIG_fail;
40536 swig_obj[0] = args;
40537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40538 if (!SWIG_IsOK(res1)) {
40539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40540 }
40541 arg1 = reinterpret_cast< wxWindow * >(argp1);
40542 {
40543 PyThreadState* __tstate = wxPyBeginAllowThreads();
40544 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40545 wxPyEndAllowThreads(__tstate);
40546 if (PyErr_Occurred()) SWIG_fail;
40547 }
40548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40549 return resultobj;
40550 fail:
40551 return NULL;
40552 }
40553
40554
40555 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40556 PyObject *resultobj = 0;
40557 wxWindow *arg1 = (wxWindow *) 0 ;
40558 bool arg2 ;
40559 void *argp1 = 0 ;
40560 int res1 = 0 ;
40561 bool val2 ;
40562 int ecode2 = 0 ;
40563 PyObject * obj0 = 0 ;
40564 PyObject * obj1 = 0 ;
40565 char * kwnames[] = {
40566 (char *) "self",(char *) "accept", NULL
40567 };
40568
40569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40571 if (!SWIG_IsOK(res1)) {
40572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40573 }
40574 arg1 = reinterpret_cast< wxWindow * >(argp1);
40575 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40576 if (!SWIG_IsOK(ecode2)) {
40577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40578 }
40579 arg2 = static_cast< bool >(val2);
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 wxWindow_DragAcceptFiles(arg1,arg2);
40583 wxPyEndAllowThreads(__tstate);
40584 if (PyErr_Occurred()) SWIG_fail;
40585 }
40586 resultobj = SWIG_Py_Void();
40587 return resultobj;
40588 fail:
40589 return NULL;
40590 }
40591
40592
40593 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40594 PyObject *resultobj = 0;
40595 wxWindow *arg1 = (wxWindow *) 0 ;
40596 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40597 void *argp1 = 0 ;
40598 int res1 = 0 ;
40599 int res2 = 0 ;
40600 PyObject * obj0 = 0 ;
40601 PyObject * obj1 = 0 ;
40602 char * kwnames[] = {
40603 (char *) "self",(char *) "constraints", NULL
40604 };
40605
40606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40608 if (!SWIG_IsOK(res1)) {
40609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40610 }
40611 arg1 = reinterpret_cast< wxWindow * >(argp1);
40612 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40613 if (!SWIG_IsOK(res2)) {
40614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40615 }
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 (arg1)->SetConstraints(arg2);
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 resultobj = SWIG_Py_Void();
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40630 PyObject *resultobj = 0;
40631 wxWindow *arg1 = (wxWindow *) 0 ;
40632 wxLayoutConstraints *result = 0 ;
40633 void *argp1 = 0 ;
40634 int res1 = 0 ;
40635 PyObject *swig_obj[1] ;
40636
40637 if (!args) SWIG_fail;
40638 swig_obj[0] = args;
40639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40642 }
40643 arg1 = reinterpret_cast< wxWindow * >(argp1);
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40647 wxPyEndAllowThreads(__tstate);
40648 if (PyErr_Occurred()) SWIG_fail;
40649 }
40650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40651 return resultobj;
40652 fail:
40653 return NULL;
40654 }
40655
40656
40657 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40658 PyObject *resultobj = 0;
40659 wxWindow *arg1 = (wxWindow *) 0 ;
40660 bool arg2 ;
40661 void *argp1 = 0 ;
40662 int res1 = 0 ;
40663 bool val2 ;
40664 int ecode2 = 0 ;
40665 PyObject * obj0 = 0 ;
40666 PyObject * obj1 = 0 ;
40667 char * kwnames[] = {
40668 (char *) "self",(char *) "autoLayout", NULL
40669 };
40670
40671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40673 if (!SWIG_IsOK(res1)) {
40674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40675 }
40676 arg1 = reinterpret_cast< wxWindow * >(argp1);
40677 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40678 if (!SWIG_IsOK(ecode2)) {
40679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40680 }
40681 arg2 = static_cast< bool >(val2);
40682 {
40683 PyThreadState* __tstate = wxPyBeginAllowThreads();
40684 (arg1)->SetAutoLayout(arg2);
40685 wxPyEndAllowThreads(__tstate);
40686 if (PyErr_Occurred()) SWIG_fail;
40687 }
40688 resultobj = SWIG_Py_Void();
40689 return resultobj;
40690 fail:
40691 return NULL;
40692 }
40693
40694
40695 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40696 PyObject *resultobj = 0;
40697 wxWindow *arg1 = (wxWindow *) 0 ;
40698 bool result;
40699 void *argp1 = 0 ;
40700 int res1 = 0 ;
40701 PyObject *swig_obj[1] ;
40702
40703 if (!args) SWIG_fail;
40704 swig_obj[0] = args;
40705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40706 if (!SWIG_IsOK(res1)) {
40707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40708 }
40709 arg1 = reinterpret_cast< wxWindow * >(argp1);
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 {
40717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40718 }
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40726 PyObject *resultobj = 0;
40727 wxWindow *arg1 = (wxWindow *) 0 ;
40728 bool result;
40729 void *argp1 = 0 ;
40730 int res1 = 0 ;
40731 PyObject *swig_obj[1] ;
40732
40733 if (!args) SWIG_fail;
40734 swig_obj[0] = args;
40735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40736 if (!SWIG_IsOK(res1)) {
40737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40738 }
40739 arg1 = reinterpret_cast< wxWindow * >(argp1);
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 result = (bool)(arg1)->Layout();
40743 wxPyEndAllowThreads(__tstate);
40744 if (PyErr_Occurred()) SWIG_fail;
40745 }
40746 {
40747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40748 }
40749 return resultobj;
40750 fail:
40751 return NULL;
40752 }
40753
40754
40755 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40756 PyObject *resultobj = 0;
40757 wxWindow *arg1 = (wxWindow *) 0 ;
40758 wxSizer *arg2 = (wxSizer *) 0 ;
40759 bool arg3 = (bool) true ;
40760 void *argp1 = 0 ;
40761 int res1 = 0 ;
40762 int res2 = 0 ;
40763 bool val3 ;
40764 int ecode3 = 0 ;
40765 PyObject * obj0 = 0 ;
40766 PyObject * obj1 = 0 ;
40767 PyObject * obj2 = 0 ;
40768 char * kwnames[] = {
40769 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40770 };
40771
40772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40774 if (!SWIG_IsOK(res1)) {
40775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40776 }
40777 arg1 = reinterpret_cast< wxWindow * >(argp1);
40778 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40779 if (!SWIG_IsOK(res2)) {
40780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40781 }
40782 if (obj2) {
40783 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40784 if (!SWIG_IsOK(ecode3)) {
40785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40786 }
40787 arg3 = static_cast< bool >(val3);
40788 }
40789 {
40790 PyThreadState* __tstate = wxPyBeginAllowThreads();
40791 (arg1)->SetSizer(arg2,arg3);
40792 wxPyEndAllowThreads(__tstate);
40793 if (PyErr_Occurred()) SWIG_fail;
40794 }
40795 resultobj = SWIG_Py_Void();
40796 return resultobj;
40797 fail:
40798 return NULL;
40799 }
40800
40801
40802 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40803 PyObject *resultobj = 0;
40804 wxWindow *arg1 = (wxWindow *) 0 ;
40805 wxSizer *arg2 = (wxSizer *) 0 ;
40806 bool arg3 = (bool) true ;
40807 void *argp1 = 0 ;
40808 int res1 = 0 ;
40809 int res2 = 0 ;
40810 bool val3 ;
40811 int ecode3 = 0 ;
40812 PyObject * obj0 = 0 ;
40813 PyObject * obj1 = 0 ;
40814 PyObject * obj2 = 0 ;
40815 char * kwnames[] = {
40816 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40817 };
40818
40819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40821 if (!SWIG_IsOK(res1)) {
40822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40823 }
40824 arg1 = reinterpret_cast< wxWindow * >(argp1);
40825 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40826 if (!SWIG_IsOK(res2)) {
40827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40828 }
40829 if (obj2) {
40830 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40831 if (!SWIG_IsOK(ecode3)) {
40832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40833 }
40834 arg3 = static_cast< bool >(val3);
40835 }
40836 {
40837 PyThreadState* __tstate = wxPyBeginAllowThreads();
40838 (arg1)->SetSizerAndFit(arg2,arg3);
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 resultobj = SWIG_Py_Void();
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40850 PyObject *resultobj = 0;
40851 wxWindow *arg1 = (wxWindow *) 0 ;
40852 wxSizer *result = 0 ;
40853 void *argp1 = 0 ;
40854 int res1 = 0 ;
40855 PyObject *swig_obj[1] ;
40856
40857 if (!args) SWIG_fail;
40858 swig_obj[0] = args;
40859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40860 if (!SWIG_IsOK(res1)) {
40861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40862 }
40863 arg1 = reinterpret_cast< wxWindow * >(argp1);
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40867 wxPyEndAllowThreads(__tstate);
40868 if (PyErr_Occurred()) SWIG_fail;
40869 }
40870 {
40871 resultobj = wxPyMake_wxObject(result, (bool)0);
40872 }
40873 return resultobj;
40874 fail:
40875 return NULL;
40876 }
40877
40878
40879 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40880 PyObject *resultobj = 0;
40881 wxWindow *arg1 = (wxWindow *) 0 ;
40882 wxSizer *arg2 = (wxSizer *) 0 ;
40883 void *argp1 = 0 ;
40884 int res1 = 0 ;
40885 void *argp2 = 0 ;
40886 int res2 = 0 ;
40887 PyObject * obj0 = 0 ;
40888 PyObject * obj1 = 0 ;
40889 char * kwnames[] = {
40890 (char *) "self",(char *) "sizer", NULL
40891 };
40892
40893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40895 if (!SWIG_IsOK(res1)) {
40896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40897 }
40898 arg1 = reinterpret_cast< wxWindow * >(argp1);
40899 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40900 if (!SWIG_IsOK(res2)) {
40901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40902 }
40903 arg2 = reinterpret_cast< wxSizer * >(argp2);
40904 {
40905 PyThreadState* __tstate = wxPyBeginAllowThreads();
40906 (arg1)->SetContainingSizer(arg2);
40907 wxPyEndAllowThreads(__tstate);
40908 if (PyErr_Occurred()) SWIG_fail;
40909 }
40910 resultobj = SWIG_Py_Void();
40911 return resultobj;
40912 fail:
40913 return NULL;
40914 }
40915
40916
40917 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40918 PyObject *resultobj = 0;
40919 wxWindow *arg1 = (wxWindow *) 0 ;
40920 wxSizer *result = 0 ;
40921 void *argp1 = 0 ;
40922 int res1 = 0 ;
40923 PyObject *swig_obj[1] ;
40924
40925 if (!args) SWIG_fail;
40926 swig_obj[0] = args;
40927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40928 if (!SWIG_IsOK(res1)) {
40929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40930 }
40931 arg1 = reinterpret_cast< wxWindow * >(argp1);
40932 {
40933 PyThreadState* __tstate = wxPyBeginAllowThreads();
40934 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 {
40939 resultobj = wxPyMake_wxObject(result, (bool)0);
40940 }
40941 return resultobj;
40942 fail:
40943 return NULL;
40944 }
40945
40946
40947 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40948 PyObject *resultobj = 0;
40949 wxWindow *arg1 = (wxWindow *) 0 ;
40950 void *argp1 = 0 ;
40951 int res1 = 0 ;
40952 PyObject *swig_obj[1] ;
40953
40954 if (!args) SWIG_fail;
40955 swig_obj[0] = args;
40956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40957 if (!SWIG_IsOK(res1)) {
40958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40959 }
40960 arg1 = reinterpret_cast< wxWindow * >(argp1);
40961 {
40962 PyThreadState* __tstate = wxPyBeginAllowThreads();
40963 (arg1)->InheritAttributes();
40964 wxPyEndAllowThreads(__tstate);
40965 if (PyErr_Occurred()) SWIG_fail;
40966 }
40967 resultobj = SWIG_Py_Void();
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40975 PyObject *resultobj = 0;
40976 wxWindow *arg1 = (wxWindow *) 0 ;
40977 bool result;
40978 void *argp1 = 0 ;
40979 int res1 = 0 ;
40980 PyObject *swig_obj[1] ;
40981
40982 if (!args) SWIG_fail;
40983 swig_obj[0] = args;
40984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40985 if (!SWIG_IsOK(res1)) {
40986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40987 }
40988 arg1 = reinterpret_cast< wxWindow * >(argp1);
40989 {
40990 PyThreadState* __tstate = wxPyBeginAllowThreads();
40991 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40992 wxPyEndAllowThreads(__tstate);
40993 if (PyErr_Occurred()) SWIG_fail;
40994 }
40995 {
40996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40997 }
40998 return resultobj;
40999 fail:
41000 return NULL;
41001 }
41002
41003
41004 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41005 PyObject *resultobj = 0;
41006 wxWindow *arg1 = (wxWindow *) 0 ;
41007 bool result;
41008 void *argp1 = 0 ;
41009 int res1 = 0 ;
41010 PyObject *swig_obj[1] ;
41011
41012 if (!args) SWIG_fail;
41013 swig_obj[0] = args;
41014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41015 if (!SWIG_IsOK(res1)) {
41016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41017 }
41018 arg1 = reinterpret_cast< wxWindow * >(argp1);
41019 {
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 result = (bool)(arg1)->CanSetTransparent();
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 {
41026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41027 }
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj = 0;
41036 wxWindow *arg1 = (wxWindow *) 0 ;
41037 byte arg2 ;
41038 bool result;
41039 void *argp1 = 0 ;
41040 int res1 = 0 ;
41041 unsigned char val2 ;
41042 int ecode2 = 0 ;
41043 PyObject * obj0 = 0 ;
41044 PyObject * obj1 = 0 ;
41045 char * kwnames[] = {
41046 (char *) "self",(char *) "alpha", NULL
41047 };
41048
41049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41051 if (!SWIG_IsOK(res1)) {
41052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41053 }
41054 arg1 = reinterpret_cast< wxWindow * >(argp1);
41055 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41056 if (!SWIG_IsOK(ecode2)) {
41057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41058 }
41059 arg2 = static_cast< byte >(val2);
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (bool)(arg1)->SetTransparent(arg2);
41063 wxPyEndAllowThreads(__tstate);
41064 if (PyErr_Occurred()) SWIG_fail;
41065 }
41066 {
41067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41068 }
41069 return resultobj;
41070 fail:
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41076 PyObject *obj;
41077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41078 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41079 return SWIG_Py_Void();
41080 }
41081
41082 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41083 return SWIG_Python_InitShadowInstance(args);
41084 }
41085
41086 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41087 PyObject *resultobj = 0;
41088 long arg1 ;
41089 wxWindow *arg2 = (wxWindow *) NULL ;
41090 wxWindow *result = 0 ;
41091 long val1 ;
41092 int ecode1 = 0 ;
41093 void *argp2 = 0 ;
41094 int res2 = 0 ;
41095 PyObject * obj0 = 0 ;
41096 PyObject * obj1 = 0 ;
41097 char * kwnames[] = {
41098 (char *) "id",(char *) "parent", NULL
41099 };
41100
41101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41102 ecode1 = SWIG_AsVal_long(obj0, &val1);
41103 if (!SWIG_IsOK(ecode1)) {
41104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41105 }
41106 arg1 = static_cast< long >(val1);
41107 if (obj1) {
41108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41109 if (!SWIG_IsOK(res2)) {
41110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41111 }
41112 arg2 = reinterpret_cast< wxWindow * >(argp2);
41113 }
41114 {
41115 if (!wxPyCheckForApp()) SWIG_fail;
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 {
41122 resultobj = wxPyMake_wxObject(result, 0);
41123 }
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41131 PyObject *resultobj = 0;
41132 wxString *arg1 = 0 ;
41133 wxWindow *arg2 = (wxWindow *) NULL ;
41134 wxWindow *result = 0 ;
41135 bool temp1 = false ;
41136 void *argp2 = 0 ;
41137 int res2 = 0 ;
41138 PyObject * obj0 = 0 ;
41139 PyObject * obj1 = 0 ;
41140 char * kwnames[] = {
41141 (char *) "name",(char *) "parent", NULL
41142 };
41143
41144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41145 {
41146 arg1 = wxString_in_helper(obj0);
41147 if (arg1 == NULL) SWIG_fail;
41148 temp1 = true;
41149 }
41150 if (obj1) {
41151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41152 if (!SWIG_IsOK(res2)) {
41153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41154 }
41155 arg2 = reinterpret_cast< wxWindow * >(argp2);
41156 }
41157 {
41158 if (!wxPyCheckForApp()) SWIG_fail;
41159 PyThreadState* __tstate = wxPyBeginAllowThreads();
41160 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41161 wxPyEndAllowThreads(__tstate);
41162 if (PyErr_Occurred()) SWIG_fail;
41163 }
41164 {
41165 resultobj = wxPyMake_wxObject(result, 0);
41166 }
41167 {
41168 if (temp1)
41169 delete arg1;
41170 }
41171 return resultobj;
41172 fail:
41173 {
41174 if (temp1)
41175 delete arg1;
41176 }
41177 return NULL;
41178 }
41179
41180
41181 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41182 PyObject *resultobj = 0;
41183 wxString *arg1 = 0 ;
41184 wxWindow *arg2 = (wxWindow *) NULL ;
41185 wxWindow *result = 0 ;
41186 bool temp1 = false ;
41187 void *argp2 = 0 ;
41188 int res2 = 0 ;
41189 PyObject * obj0 = 0 ;
41190 PyObject * obj1 = 0 ;
41191 char * kwnames[] = {
41192 (char *) "label",(char *) "parent", NULL
41193 };
41194
41195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41196 {
41197 arg1 = wxString_in_helper(obj0);
41198 if (arg1 == NULL) SWIG_fail;
41199 temp1 = true;
41200 }
41201 if (obj1) {
41202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41203 if (!SWIG_IsOK(res2)) {
41204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41205 }
41206 arg2 = reinterpret_cast< wxWindow * >(argp2);
41207 }
41208 {
41209 if (!wxPyCheckForApp()) SWIG_fail;
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41212 wxPyEndAllowThreads(__tstate);
41213 if (PyErr_Occurred()) SWIG_fail;
41214 }
41215 {
41216 resultobj = wxPyMake_wxObject(result, 0);
41217 }
41218 {
41219 if (temp1)
41220 delete arg1;
41221 }
41222 return resultobj;
41223 fail:
41224 {
41225 if (temp1)
41226 delete arg1;
41227 }
41228 return NULL;
41229 }
41230
41231
41232 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41233 PyObject *resultobj = 0;
41234 wxWindow *arg1 = (wxWindow *) 0 ;
41235 unsigned long arg2 ;
41236 wxWindow *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 unsigned long val2 ;
41240 int ecode2 = 0 ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 char * kwnames[] = {
41244 (char *) "parent",(char *) "_hWnd", NULL
41245 };
41246
41247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41249 if (!SWIG_IsOK(res1)) {
41250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41251 }
41252 arg1 = reinterpret_cast< wxWindow * >(argp1);
41253 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41254 if (!SWIG_IsOK(ecode2)) {
41255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41256 }
41257 arg2 = static_cast< unsigned long >(val2);
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41274 PyObject *resultobj = 0;
41275 PyObject *result = 0 ;
41276
41277 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41278 {
41279 PyThreadState* __tstate = wxPyBeginAllowThreads();
41280 result = (PyObject *)GetTopLevelWindows();
41281 wxPyEndAllowThreads(__tstate);
41282 if (PyErr_Occurred()) SWIG_fail;
41283 }
41284 resultobj = result;
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41292 PyObject *resultobj = 0;
41293 wxValidator *result = 0 ;
41294
41295 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41296 {
41297 PyThreadState* __tstate = wxPyBeginAllowThreads();
41298 result = (wxValidator *)new wxValidator();
41299 wxPyEndAllowThreads(__tstate);
41300 if (PyErr_Occurred()) SWIG_fail;
41301 }
41302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41303 return resultobj;
41304 fail:
41305 return NULL;
41306 }
41307
41308
41309 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41310 PyObject *resultobj = 0;
41311 wxValidator *arg1 = (wxValidator *) 0 ;
41312 wxValidator *result = 0 ;
41313 void *argp1 = 0 ;
41314 int res1 = 0 ;
41315 PyObject *swig_obj[1] ;
41316
41317 if (!args) SWIG_fail;
41318 swig_obj[0] = args;
41319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41320 if (!SWIG_IsOK(res1)) {
41321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41322 }
41323 arg1 = reinterpret_cast< wxValidator * >(argp1);
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 result = (wxValidator *)(arg1)->Clone();
41327 wxPyEndAllowThreads(__tstate);
41328 if (PyErr_Occurred()) SWIG_fail;
41329 }
41330 {
41331 resultobj = wxPyMake_wxObject(result, 0);
41332 }
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41340 PyObject *resultobj = 0;
41341 wxValidator *arg1 = (wxValidator *) 0 ;
41342 wxWindow *arg2 = (wxWindow *) 0 ;
41343 bool result;
41344 void *argp1 = 0 ;
41345 int res1 = 0 ;
41346 void *argp2 = 0 ;
41347 int res2 = 0 ;
41348 PyObject * obj0 = 0 ;
41349 PyObject * obj1 = 0 ;
41350 char * kwnames[] = {
41351 (char *) "self",(char *) "parent", NULL
41352 };
41353
41354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41356 if (!SWIG_IsOK(res1)) {
41357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41358 }
41359 arg1 = reinterpret_cast< wxValidator * >(argp1);
41360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41361 if (!SWIG_IsOK(res2)) {
41362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41363 }
41364 arg2 = reinterpret_cast< wxWindow * >(argp2);
41365 {
41366 PyThreadState* __tstate = wxPyBeginAllowThreads();
41367 result = (bool)(arg1)->Validate(arg2);
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 {
41372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41373 }
41374 return resultobj;
41375 fail:
41376 return NULL;
41377 }
41378
41379
41380 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41381 PyObject *resultobj = 0;
41382 wxValidator *arg1 = (wxValidator *) 0 ;
41383 bool result;
41384 void *argp1 = 0 ;
41385 int res1 = 0 ;
41386 PyObject *swig_obj[1] ;
41387
41388 if (!args) SWIG_fail;
41389 swig_obj[0] = args;
41390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41391 if (!SWIG_IsOK(res1)) {
41392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41393 }
41394 arg1 = reinterpret_cast< wxValidator * >(argp1);
41395 {
41396 PyThreadState* __tstate = wxPyBeginAllowThreads();
41397 result = (bool)(arg1)->TransferToWindow();
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 {
41402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41403 }
41404 return resultobj;
41405 fail:
41406 return NULL;
41407 }
41408
41409
41410 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41411 PyObject *resultobj = 0;
41412 wxValidator *arg1 = (wxValidator *) 0 ;
41413 bool result;
41414 void *argp1 = 0 ;
41415 int res1 = 0 ;
41416 PyObject *swig_obj[1] ;
41417
41418 if (!args) SWIG_fail;
41419 swig_obj[0] = args;
41420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41421 if (!SWIG_IsOK(res1)) {
41422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41423 }
41424 arg1 = reinterpret_cast< wxValidator * >(argp1);
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 result = (bool)(arg1)->TransferFromWindow();
41428 wxPyEndAllowThreads(__tstate);
41429 if (PyErr_Occurred()) SWIG_fail;
41430 }
41431 {
41432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41433 }
41434 return resultobj;
41435 fail:
41436 return NULL;
41437 }
41438
41439
41440 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41441 PyObject *resultobj = 0;
41442 wxValidator *arg1 = (wxValidator *) 0 ;
41443 wxWindow *result = 0 ;
41444 void *argp1 = 0 ;
41445 int res1 = 0 ;
41446 PyObject *swig_obj[1] ;
41447
41448 if (!args) SWIG_fail;
41449 swig_obj[0] = args;
41450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41451 if (!SWIG_IsOK(res1)) {
41452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41453 }
41454 arg1 = reinterpret_cast< wxValidator * >(argp1);
41455 {
41456 PyThreadState* __tstate = wxPyBeginAllowThreads();
41457 result = (wxWindow *)(arg1)->GetWindow();
41458 wxPyEndAllowThreads(__tstate);
41459 if (PyErr_Occurred()) SWIG_fail;
41460 }
41461 {
41462 resultobj = wxPyMake_wxObject(result, 0);
41463 }
41464 return resultobj;
41465 fail:
41466 return NULL;
41467 }
41468
41469
41470 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41471 PyObject *resultobj = 0;
41472 wxValidator *arg1 = (wxValidator *) 0 ;
41473 wxWindow *arg2 = (wxWindow *) 0 ;
41474 void *argp1 = 0 ;
41475 int res1 = 0 ;
41476 void *argp2 = 0 ;
41477 int res2 = 0 ;
41478 PyObject * obj0 = 0 ;
41479 PyObject * obj1 = 0 ;
41480 char * kwnames[] = {
41481 (char *) "self",(char *) "window", NULL
41482 };
41483
41484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41486 if (!SWIG_IsOK(res1)) {
41487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41488 }
41489 arg1 = reinterpret_cast< wxValidator * >(argp1);
41490 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41491 if (!SWIG_IsOK(res2)) {
41492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41493 }
41494 arg2 = reinterpret_cast< wxWindow * >(argp2);
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 (arg1)->SetWindow(arg2);
41498 wxPyEndAllowThreads(__tstate);
41499 if (PyErr_Occurred()) SWIG_fail;
41500 }
41501 resultobj = SWIG_Py_Void();
41502 return resultobj;
41503 fail:
41504 return NULL;
41505 }
41506
41507
41508 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41509 PyObject *resultobj = 0;
41510 bool result;
41511
41512 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 result = (bool)wxValidator::IsSilent();
41516 wxPyEndAllowThreads(__tstate);
41517 if (PyErr_Occurred()) SWIG_fail;
41518 }
41519 {
41520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41521 }
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41529 PyObject *resultobj = 0;
41530 int arg1 = (int) true ;
41531 int val1 ;
41532 int ecode1 = 0 ;
41533 PyObject * obj0 = 0 ;
41534 char * kwnames[] = {
41535 (char *) "doIt", NULL
41536 };
41537
41538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41539 if (obj0) {
41540 ecode1 = SWIG_AsVal_int(obj0, &val1);
41541 if (!SWIG_IsOK(ecode1)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41543 }
41544 arg1 = static_cast< int >(val1);
41545 }
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 wxValidator::SetBellOnError(arg1);
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 resultobj = SWIG_Py_Void();
41553 return resultobj;
41554 fail:
41555 return NULL;
41556 }
41557
41558
41559 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41560 PyObject *obj;
41561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41562 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41563 return SWIG_Py_Void();
41564 }
41565
41566 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41567 return SWIG_Python_InitShadowInstance(args);
41568 }
41569
41570 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41571 PyObject *resultobj = 0;
41572 wxPyValidator *result = 0 ;
41573
41574 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41575 {
41576 PyThreadState* __tstate = wxPyBeginAllowThreads();
41577 result = (wxPyValidator *)new wxPyValidator();
41578 wxPyEndAllowThreads(__tstate);
41579 if (PyErr_Occurred()) SWIG_fail;
41580 }
41581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41582 return resultobj;
41583 fail:
41584 return NULL;
41585 }
41586
41587
41588 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41589 PyObject *resultobj = 0;
41590 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41591 PyObject *arg2 = (PyObject *) 0 ;
41592 PyObject *arg3 = (PyObject *) 0 ;
41593 int arg4 = (int) true ;
41594 void *argp1 = 0 ;
41595 int res1 = 0 ;
41596 int val4 ;
41597 int ecode4 = 0 ;
41598 PyObject * obj0 = 0 ;
41599 PyObject * obj1 = 0 ;
41600 PyObject * obj2 = 0 ;
41601 PyObject * obj3 = 0 ;
41602 char * kwnames[] = {
41603 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41604 };
41605
41606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41608 if (!SWIG_IsOK(res1)) {
41609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41610 }
41611 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41612 arg2 = obj1;
41613 arg3 = obj2;
41614 if (obj3) {
41615 ecode4 = SWIG_AsVal_int(obj3, &val4);
41616 if (!SWIG_IsOK(ecode4)) {
41617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41618 }
41619 arg4 = static_cast< int >(val4);
41620 }
41621 {
41622 PyThreadState* __tstate = wxPyBeginAllowThreads();
41623 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41624 wxPyEndAllowThreads(__tstate);
41625 if (PyErr_Occurred()) SWIG_fail;
41626 }
41627 resultobj = SWIG_Py_Void();
41628 return resultobj;
41629 fail:
41630 return NULL;
41631 }
41632
41633
41634 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41635 PyObject *obj;
41636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41637 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41638 return SWIG_Py_Void();
41639 }
41640
41641 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41642 return SWIG_Python_InitShadowInstance(args);
41643 }
41644
41645 SWIGINTERN int DefaultValidator_set(PyObject *) {
41646 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41647 return 1;
41648 }
41649
41650
41651 SWIGINTERN PyObject *DefaultValidator_get(void) {
41652 PyObject *pyobj = 0;
41653
41654 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41655 return pyobj;
41656 }
41657
41658
41659 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41660 PyObject *resultobj = 0;
41661 wxString const &arg1_defvalue = wxPyEmptyString ;
41662 wxString *arg1 = (wxString *) &arg1_defvalue ;
41663 long arg2 = (long) 0 ;
41664 wxMenu *result = 0 ;
41665 bool temp1 = false ;
41666 long val2 ;
41667 int ecode2 = 0 ;
41668 PyObject * obj0 = 0 ;
41669 PyObject * obj1 = 0 ;
41670 char * kwnames[] = {
41671 (char *) "title",(char *) "style", NULL
41672 };
41673
41674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41675 if (obj0) {
41676 {
41677 arg1 = wxString_in_helper(obj0);
41678 if (arg1 == NULL) SWIG_fail;
41679 temp1 = true;
41680 }
41681 }
41682 if (obj1) {
41683 ecode2 = SWIG_AsVal_long(obj1, &val2);
41684 if (!SWIG_IsOK(ecode2)) {
41685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41686 }
41687 arg2 = static_cast< long >(val2);
41688 }
41689 {
41690 if (!wxPyCheckForApp()) SWIG_fail;
41691 PyThreadState* __tstate = wxPyBeginAllowThreads();
41692 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41693 wxPyEndAllowThreads(__tstate);
41694 if (PyErr_Occurred()) SWIG_fail;
41695 }
41696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41697 {
41698 if (temp1)
41699 delete arg1;
41700 }
41701 return resultobj;
41702 fail:
41703 {
41704 if (temp1)
41705 delete arg1;
41706 }
41707 return NULL;
41708 }
41709
41710
41711 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41712 PyObject *resultobj = 0;
41713 wxMenu *arg1 = (wxMenu *) 0 ;
41714 int arg2 ;
41715 wxString const &arg3_defvalue = wxPyEmptyString ;
41716 wxString *arg3 = (wxString *) &arg3_defvalue ;
41717 wxString const &arg4_defvalue = wxPyEmptyString ;
41718 wxString *arg4 = (wxString *) &arg4_defvalue ;
41719 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41720 wxMenuItem *result = 0 ;
41721 void *argp1 = 0 ;
41722 int res1 = 0 ;
41723 int val2 ;
41724 int ecode2 = 0 ;
41725 bool temp3 = false ;
41726 bool temp4 = false ;
41727 int val5 ;
41728 int ecode5 = 0 ;
41729 PyObject * obj0 = 0 ;
41730 PyObject * obj1 = 0 ;
41731 PyObject * obj2 = 0 ;
41732 PyObject * obj3 = 0 ;
41733 PyObject * obj4 = 0 ;
41734 char * kwnames[] = {
41735 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41736 };
41737
41738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41740 if (!SWIG_IsOK(res1)) {
41741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41742 }
41743 arg1 = reinterpret_cast< wxMenu * >(argp1);
41744 ecode2 = SWIG_AsVal_int(obj1, &val2);
41745 if (!SWIG_IsOK(ecode2)) {
41746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41747 }
41748 arg2 = static_cast< int >(val2);
41749 if (obj2) {
41750 {
41751 arg3 = wxString_in_helper(obj2);
41752 if (arg3 == NULL) SWIG_fail;
41753 temp3 = true;
41754 }
41755 }
41756 if (obj3) {
41757 {
41758 arg4 = wxString_in_helper(obj3);
41759 if (arg4 == NULL) SWIG_fail;
41760 temp4 = true;
41761 }
41762 }
41763 if (obj4) {
41764 ecode5 = SWIG_AsVal_int(obj4, &val5);
41765 if (!SWIG_IsOK(ecode5)) {
41766 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41767 }
41768 arg5 = static_cast< wxItemKind >(val5);
41769 }
41770 {
41771 PyThreadState* __tstate = wxPyBeginAllowThreads();
41772 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41773 wxPyEndAllowThreads(__tstate);
41774 if (PyErr_Occurred()) SWIG_fail;
41775 }
41776 {
41777 resultobj = wxPyMake_wxObject(result, (bool)0);
41778 }
41779 {
41780 if (temp3)
41781 delete arg3;
41782 }
41783 {
41784 if (temp4)
41785 delete arg4;
41786 }
41787 return resultobj;
41788 fail:
41789 {
41790 if (temp3)
41791 delete arg3;
41792 }
41793 {
41794 if (temp4)
41795 delete arg4;
41796 }
41797 return NULL;
41798 }
41799
41800
41801 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41802 PyObject *resultobj = 0;
41803 wxMenu *arg1 = (wxMenu *) 0 ;
41804 wxMenuItem *result = 0 ;
41805 void *argp1 = 0 ;
41806 int res1 = 0 ;
41807 PyObject *swig_obj[1] ;
41808
41809 if (!args) SWIG_fail;
41810 swig_obj[0] = args;
41811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41812 if (!SWIG_IsOK(res1)) {
41813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41814 }
41815 arg1 = reinterpret_cast< wxMenu * >(argp1);
41816 {
41817 PyThreadState* __tstate = wxPyBeginAllowThreads();
41818 result = (wxMenuItem *)(arg1)->AppendSeparator();
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 {
41823 resultobj = wxPyMake_wxObject(result, (bool)0);
41824 }
41825 return resultobj;
41826 fail:
41827 return NULL;
41828 }
41829
41830
41831 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41832 PyObject *resultobj = 0;
41833 wxMenu *arg1 = (wxMenu *) 0 ;
41834 int arg2 ;
41835 wxString *arg3 = 0 ;
41836 wxString const &arg4_defvalue = wxPyEmptyString ;
41837 wxString *arg4 = (wxString *) &arg4_defvalue ;
41838 wxMenuItem *result = 0 ;
41839 void *argp1 = 0 ;
41840 int res1 = 0 ;
41841 int val2 ;
41842 int ecode2 = 0 ;
41843 bool temp3 = false ;
41844 bool temp4 = false ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 PyObject * obj2 = 0 ;
41848 PyObject * obj3 = 0 ;
41849 char * kwnames[] = {
41850 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41851 };
41852
41853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41855 if (!SWIG_IsOK(res1)) {
41856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41857 }
41858 arg1 = reinterpret_cast< wxMenu * >(argp1);
41859 ecode2 = SWIG_AsVal_int(obj1, &val2);
41860 if (!SWIG_IsOK(ecode2)) {
41861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41862 }
41863 arg2 = static_cast< int >(val2);
41864 {
41865 arg3 = wxString_in_helper(obj2);
41866 if (arg3 == NULL) SWIG_fail;
41867 temp3 = true;
41868 }
41869 if (obj3) {
41870 {
41871 arg4 = wxString_in_helper(obj3);
41872 if (arg4 == NULL) SWIG_fail;
41873 temp4 = true;
41874 }
41875 }
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 {
41883 resultobj = wxPyMake_wxObject(result, (bool)0);
41884 }
41885 {
41886 if (temp3)
41887 delete arg3;
41888 }
41889 {
41890 if (temp4)
41891 delete arg4;
41892 }
41893 return resultobj;
41894 fail:
41895 {
41896 if (temp3)
41897 delete arg3;
41898 }
41899 {
41900 if (temp4)
41901 delete arg4;
41902 }
41903 return NULL;
41904 }
41905
41906
41907 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41908 PyObject *resultobj = 0;
41909 wxMenu *arg1 = (wxMenu *) 0 ;
41910 int arg2 ;
41911 wxString *arg3 = 0 ;
41912 wxString const &arg4_defvalue = wxPyEmptyString ;
41913 wxString *arg4 = (wxString *) &arg4_defvalue ;
41914 wxMenuItem *result = 0 ;
41915 void *argp1 = 0 ;
41916 int res1 = 0 ;
41917 int val2 ;
41918 int ecode2 = 0 ;
41919 bool temp3 = false ;
41920 bool temp4 = false ;
41921 PyObject * obj0 = 0 ;
41922 PyObject * obj1 = 0 ;
41923 PyObject * obj2 = 0 ;
41924 PyObject * obj3 = 0 ;
41925 char * kwnames[] = {
41926 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41927 };
41928
41929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41931 if (!SWIG_IsOK(res1)) {
41932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41933 }
41934 arg1 = reinterpret_cast< wxMenu * >(argp1);
41935 ecode2 = SWIG_AsVal_int(obj1, &val2);
41936 if (!SWIG_IsOK(ecode2)) {
41937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41938 }
41939 arg2 = static_cast< int >(val2);
41940 {
41941 arg3 = wxString_in_helper(obj2);
41942 if (arg3 == NULL) SWIG_fail;
41943 temp3 = true;
41944 }
41945 if (obj3) {
41946 {
41947 arg4 = wxString_in_helper(obj3);
41948 if (arg4 == NULL) SWIG_fail;
41949 temp4 = true;
41950 }
41951 }
41952 {
41953 PyThreadState* __tstate = wxPyBeginAllowThreads();
41954 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41955 wxPyEndAllowThreads(__tstate);
41956 if (PyErr_Occurred()) SWIG_fail;
41957 }
41958 {
41959 resultobj = wxPyMake_wxObject(result, (bool)0);
41960 }
41961 {
41962 if (temp3)
41963 delete arg3;
41964 }
41965 {
41966 if (temp4)
41967 delete arg4;
41968 }
41969 return resultobj;
41970 fail:
41971 {
41972 if (temp3)
41973 delete arg3;
41974 }
41975 {
41976 if (temp4)
41977 delete arg4;
41978 }
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41984 PyObject *resultobj = 0;
41985 wxMenu *arg1 = (wxMenu *) 0 ;
41986 int arg2 ;
41987 wxString *arg3 = 0 ;
41988 wxMenu *arg4 = (wxMenu *) 0 ;
41989 wxString const &arg5_defvalue = wxPyEmptyString ;
41990 wxString *arg5 = (wxString *) &arg5_defvalue ;
41991 wxMenuItem *result = 0 ;
41992 void *argp1 = 0 ;
41993 int res1 = 0 ;
41994 int val2 ;
41995 int ecode2 = 0 ;
41996 bool temp3 = false ;
41997 void *argp4 = 0 ;
41998 int res4 = 0 ;
41999 bool temp5 = false ;
42000 PyObject * obj0 = 0 ;
42001 PyObject * obj1 = 0 ;
42002 PyObject * obj2 = 0 ;
42003 PyObject * obj3 = 0 ;
42004 PyObject * obj4 = 0 ;
42005 char * kwnames[] = {
42006 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42007 };
42008
42009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42011 if (!SWIG_IsOK(res1)) {
42012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42013 }
42014 arg1 = reinterpret_cast< wxMenu * >(argp1);
42015 ecode2 = SWIG_AsVal_int(obj1, &val2);
42016 if (!SWIG_IsOK(ecode2)) {
42017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42018 }
42019 arg2 = static_cast< int >(val2);
42020 {
42021 arg3 = wxString_in_helper(obj2);
42022 if (arg3 == NULL) SWIG_fail;
42023 temp3 = true;
42024 }
42025 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42026 if (!SWIG_IsOK(res4)) {
42027 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42028 }
42029 arg4 = reinterpret_cast< wxMenu * >(argp4);
42030 if (obj4) {
42031 {
42032 arg5 = wxString_in_helper(obj4);
42033 if (arg5 == NULL) SWIG_fail;
42034 temp5 = true;
42035 }
42036 }
42037 {
42038 PyThreadState* __tstate = wxPyBeginAllowThreads();
42039 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42040 wxPyEndAllowThreads(__tstate);
42041 if (PyErr_Occurred()) SWIG_fail;
42042 }
42043 {
42044 resultobj = wxPyMake_wxObject(result, (bool)0);
42045 }
42046 {
42047 if (temp3)
42048 delete arg3;
42049 }
42050 {
42051 if (temp5)
42052 delete arg5;
42053 }
42054 return resultobj;
42055 fail:
42056 {
42057 if (temp3)
42058 delete arg3;
42059 }
42060 {
42061 if (temp5)
42062 delete arg5;
42063 }
42064 return NULL;
42065 }
42066
42067
42068 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42069 PyObject *resultobj = 0;
42070 wxMenu *arg1 = (wxMenu *) 0 ;
42071 wxMenu *arg2 = (wxMenu *) 0 ;
42072 wxString *arg3 = 0 ;
42073 wxString const &arg4_defvalue = wxPyEmptyString ;
42074 wxString *arg4 = (wxString *) &arg4_defvalue ;
42075 wxMenuItem *result = 0 ;
42076 void *argp1 = 0 ;
42077 int res1 = 0 ;
42078 void *argp2 = 0 ;
42079 int res2 = 0 ;
42080 bool temp3 = false ;
42081 bool temp4 = false ;
42082 PyObject * obj0 = 0 ;
42083 PyObject * obj1 = 0 ;
42084 PyObject * obj2 = 0 ;
42085 PyObject * obj3 = 0 ;
42086 char * kwnames[] = {
42087 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42088 };
42089
42090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42092 if (!SWIG_IsOK(res1)) {
42093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42094 }
42095 arg1 = reinterpret_cast< wxMenu * >(argp1);
42096 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42097 if (!SWIG_IsOK(res2)) {
42098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42099 }
42100 arg2 = reinterpret_cast< wxMenu * >(argp2);
42101 {
42102 arg3 = wxString_in_helper(obj2);
42103 if (arg3 == NULL) SWIG_fail;
42104 temp3 = true;
42105 }
42106 if (obj3) {
42107 {
42108 arg4 = wxString_in_helper(obj3);
42109 if (arg4 == NULL) SWIG_fail;
42110 temp4 = true;
42111 }
42112 }
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 {
42120 resultobj = wxPyMake_wxObject(result, (bool)0);
42121 }
42122 {
42123 if (temp3)
42124 delete arg3;
42125 }
42126 {
42127 if (temp4)
42128 delete arg4;
42129 }
42130 return resultobj;
42131 fail:
42132 {
42133 if (temp3)
42134 delete arg3;
42135 }
42136 {
42137 if (temp4)
42138 delete arg4;
42139 }
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42145 PyObject *resultobj = 0;
42146 wxMenu *arg1 = (wxMenu *) 0 ;
42147 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42148 wxMenuItem *result = 0 ;
42149 void *argp1 = 0 ;
42150 int res1 = 0 ;
42151 int res2 = 0 ;
42152 PyObject * obj0 = 0 ;
42153 PyObject * obj1 = 0 ;
42154 char * kwnames[] = {
42155 (char *) "self",(char *) "item", NULL
42156 };
42157
42158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42160 if (!SWIG_IsOK(res1)) {
42161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42162 }
42163 arg1 = reinterpret_cast< wxMenu * >(argp1);
42164 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42165 if (!SWIG_IsOK(res2)) {
42166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42167 }
42168 {
42169 PyThreadState* __tstate = wxPyBeginAllowThreads();
42170 result = (wxMenuItem *)(arg1)->Append(arg2);
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 {
42175 resultobj = wxPyMake_wxObject(result, (bool)0);
42176 }
42177 return resultobj;
42178 fail:
42179 return NULL;
42180 }
42181
42182
42183 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42184 PyObject *resultobj = 0;
42185 wxMenu *arg1 = (wxMenu *) 0 ;
42186 size_t arg2 ;
42187 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42188 wxMenuItem *result = 0 ;
42189 void *argp1 = 0 ;
42190 int res1 = 0 ;
42191 size_t val2 ;
42192 int ecode2 = 0 ;
42193 int res3 = 0 ;
42194 PyObject * obj0 = 0 ;
42195 PyObject * obj1 = 0 ;
42196 PyObject * obj2 = 0 ;
42197 char * kwnames[] = {
42198 (char *) "self",(char *) "pos",(char *) "item", NULL
42199 };
42200
42201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42203 if (!SWIG_IsOK(res1)) {
42204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42205 }
42206 arg1 = reinterpret_cast< wxMenu * >(argp1);
42207 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42208 if (!SWIG_IsOK(ecode2)) {
42209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42210 }
42211 arg2 = static_cast< size_t >(val2);
42212 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42213 if (!SWIG_IsOK(res3)) {
42214 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42215 }
42216 {
42217 PyThreadState* __tstate = wxPyBeginAllowThreads();
42218 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 {
42223 resultobj = wxPyMake_wxObject(result, (bool)0);
42224 }
42225 return resultobj;
42226 fail:
42227 return NULL;
42228 }
42229
42230
42231 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42232 PyObject *resultobj = 0;
42233 wxMenu *arg1 = (wxMenu *) 0 ;
42234 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42235 wxMenuItem *result = 0 ;
42236 void *argp1 = 0 ;
42237 int res1 = 0 ;
42238 int res2 = 0 ;
42239 PyObject * obj0 = 0 ;
42240 PyObject * obj1 = 0 ;
42241 char * kwnames[] = {
42242 (char *) "self",(char *) "item", NULL
42243 };
42244
42245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42247 if (!SWIG_IsOK(res1)) {
42248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42249 }
42250 arg1 = reinterpret_cast< wxMenu * >(argp1);
42251 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42252 if (!SWIG_IsOK(res2)) {
42253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42254 }
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 {
42262 resultobj = wxPyMake_wxObject(result, (bool)0);
42263 }
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42271 PyObject *resultobj = 0;
42272 wxMenu *arg1 = (wxMenu *) 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_wxMenu, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42282 }
42283 arg1 = reinterpret_cast< wxMenu * >(argp1);
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 (arg1)->Break();
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 resultobj = SWIG_Py_Void();
42291 return resultobj;
42292 fail:
42293 return NULL;
42294 }
42295
42296
42297 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42298 PyObject *resultobj = 0;
42299 wxMenu *arg1 = (wxMenu *) 0 ;
42300 size_t arg2 ;
42301 int arg3 ;
42302 wxString const &arg4_defvalue = wxPyEmptyString ;
42303 wxString *arg4 = (wxString *) &arg4_defvalue ;
42304 wxString const &arg5_defvalue = wxPyEmptyString ;
42305 wxString *arg5 = (wxString *) &arg5_defvalue ;
42306 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42307 wxMenuItem *result = 0 ;
42308 void *argp1 = 0 ;
42309 int res1 = 0 ;
42310 size_t val2 ;
42311 int ecode2 = 0 ;
42312 int val3 ;
42313 int ecode3 = 0 ;
42314 bool temp4 = false ;
42315 bool temp5 = false ;
42316 int val6 ;
42317 int ecode6 = 0 ;
42318 PyObject * obj0 = 0 ;
42319 PyObject * obj1 = 0 ;
42320 PyObject * obj2 = 0 ;
42321 PyObject * obj3 = 0 ;
42322 PyObject * obj4 = 0 ;
42323 PyObject * obj5 = 0 ;
42324 char * kwnames[] = {
42325 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42326 };
42327
42328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42330 if (!SWIG_IsOK(res1)) {
42331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42332 }
42333 arg1 = reinterpret_cast< wxMenu * >(argp1);
42334 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42335 if (!SWIG_IsOK(ecode2)) {
42336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42337 }
42338 arg2 = static_cast< size_t >(val2);
42339 ecode3 = SWIG_AsVal_int(obj2, &val3);
42340 if (!SWIG_IsOK(ecode3)) {
42341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42342 }
42343 arg3 = static_cast< int >(val3);
42344 if (obj3) {
42345 {
42346 arg4 = wxString_in_helper(obj3);
42347 if (arg4 == NULL) SWIG_fail;
42348 temp4 = true;
42349 }
42350 }
42351 if (obj4) {
42352 {
42353 arg5 = wxString_in_helper(obj4);
42354 if (arg5 == NULL) SWIG_fail;
42355 temp5 = true;
42356 }
42357 }
42358 if (obj5) {
42359 ecode6 = SWIG_AsVal_int(obj5, &val6);
42360 if (!SWIG_IsOK(ecode6)) {
42361 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42362 }
42363 arg6 = static_cast< wxItemKind >(val6);
42364 }
42365 {
42366 PyThreadState* __tstate = wxPyBeginAllowThreads();
42367 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42368 wxPyEndAllowThreads(__tstate);
42369 if (PyErr_Occurred()) SWIG_fail;
42370 }
42371 {
42372 resultobj = wxPyMake_wxObject(result, (bool)0);
42373 }
42374 {
42375 if (temp4)
42376 delete arg4;
42377 }
42378 {
42379 if (temp5)
42380 delete arg5;
42381 }
42382 return resultobj;
42383 fail:
42384 {
42385 if (temp4)
42386 delete arg4;
42387 }
42388 {
42389 if (temp5)
42390 delete arg5;
42391 }
42392 return NULL;
42393 }
42394
42395
42396 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42397 PyObject *resultobj = 0;
42398 wxMenu *arg1 = (wxMenu *) 0 ;
42399 size_t arg2 ;
42400 wxMenuItem *result = 0 ;
42401 void *argp1 = 0 ;
42402 int res1 = 0 ;
42403 size_t val2 ;
42404 int ecode2 = 0 ;
42405 PyObject * obj0 = 0 ;
42406 PyObject * obj1 = 0 ;
42407 char * kwnames[] = {
42408 (char *) "self",(char *) "pos", NULL
42409 };
42410
42411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42413 if (!SWIG_IsOK(res1)) {
42414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42415 }
42416 arg1 = reinterpret_cast< wxMenu * >(argp1);
42417 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42418 if (!SWIG_IsOK(ecode2)) {
42419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42420 }
42421 arg2 = static_cast< size_t >(val2);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 {
42429 resultobj = wxPyMake_wxObject(result, (bool)0);
42430 }
42431 return resultobj;
42432 fail:
42433 return NULL;
42434 }
42435
42436
42437 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj = 0;
42439 wxMenu *arg1 = (wxMenu *) 0 ;
42440 size_t arg2 ;
42441 int arg3 ;
42442 wxString *arg4 = 0 ;
42443 wxString const &arg5_defvalue = wxPyEmptyString ;
42444 wxString *arg5 = (wxString *) &arg5_defvalue ;
42445 wxMenuItem *result = 0 ;
42446 void *argp1 = 0 ;
42447 int res1 = 0 ;
42448 size_t val2 ;
42449 int ecode2 = 0 ;
42450 int val3 ;
42451 int ecode3 = 0 ;
42452 bool temp4 = false ;
42453 bool temp5 = false ;
42454 PyObject * obj0 = 0 ;
42455 PyObject * obj1 = 0 ;
42456 PyObject * obj2 = 0 ;
42457 PyObject * obj3 = 0 ;
42458 PyObject * obj4 = 0 ;
42459 char * kwnames[] = {
42460 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42461 };
42462
42463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42465 if (!SWIG_IsOK(res1)) {
42466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42467 }
42468 arg1 = reinterpret_cast< wxMenu * >(argp1);
42469 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42470 if (!SWIG_IsOK(ecode2)) {
42471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42472 }
42473 arg2 = static_cast< size_t >(val2);
42474 ecode3 = SWIG_AsVal_int(obj2, &val3);
42475 if (!SWIG_IsOK(ecode3)) {
42476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42477 }
42478 arg3 = static_cast< int >(val3);
42479 {
42480 arg4 = wxString_in_helper(obj3);
42481 if (arg4 == NULL) SWIG_fail;
42482 temp4 = true;
42483 }
42484 if (obj4) {
42485 {
42486 arg5 = wxString_in_helper(obj4);
42487 if (arg5 == NULL) SWIG_fail;
42488 temp5 = true;
42489 }
42490 }
42491 {
42492 PyThreadState* __tstate = wxPyBeginAllowThreads();
42493 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42494 wxPyEndAllowThreads(__tstate);
42495 if (PyErr_Occurred()) SWIG_fail;
42496 }
42497 {
42498 resultobj = wxPyMake_wxObject(result, (bool)0);
42499 }
42500 {
42501 if (temp4)
42502 delete arg4;
42503 }
42504 {
42505 if (temp5)
42506 delete arg5;
42507 }
42508 return resultobj;
42509 fail:
42510 {
42511 if (temp4)
42512 delete arg4;
42513 }
42514 {
42515 if (temp5)
42516 delete arg5;
42517 }
42518 return NULL;
42519 }
42520
42521
42522 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42523 PyObject *resultobj = 0;
42524 wxMenu *arg1 = (wxMenu *) 0 ;
42525 size_t arg2 ;
42526 int arg3 ;
42527 wxString *arg4 = 0 ;
42528 wxString const &arg5_defvalue = wxPyEmptyString ;
42529 wxString *arg5 = (wxString *) &arg5_defvalue ;
42530 wxMenuItem *result = 0 ;
42531 void *argp1 = 0 ;
42532 int res1 = 0 ;
42533 size_t val2 ;
42534 int ecode2 = 0 ;
42535 int val3 ;
42536 int ecode3 = 0 ;
42537 bool temp4 = false ;
42538 bool temp5 = false ;
42539 PyObject * obj0 = 0 ;
42540 PyObject * obj1 = 0 ;
42541 PyObject * obj2 = 0 ;
42542 PyObject * obj3 = 0 ;
42543 PyObject * obj4 = 0 ;
42544 char * kwnames[] = {
42545 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42546 };
42547
42548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42550 if (!SWIG_IsOK(res1)) {
42551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42552 }
42553 arg1 = reinterpret_cast< wxMenu * >(argp1);
42554 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42555 if (!SWIG_IsOK(ecode2)) {
42556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42557 }
42558 arg2 = static_cast< size_t >(val2);
42559 ecode3 = SWIG_AsVal_int(obj2, &val3);
42560 if (!SWIG_IsOK(ecode3)) {
42561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42562 }
42563 arg3 = static_cast< int >(val3);
42564 {
42565 arg4 = wxString_in_helper(obj3);
42566 if (arg4 == NULL) SWIG_fail;
42567 temp4 = true;
42568 }
42569 if (obj4) {
42570 {
42571 arg5 = wxString_in_helper(obj4);
42572 if (arg5 == NULL) SWIG_fail;
42573 temp5 = true;
42574 }
42575 }
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = wxPyMake_wxObject(result, (bool)0);
42584 }
42585 {
42586 if (temp4)
42587 delete arg4;
42588 }
42589 {
42590 if (temp5)
42591 delete arg5;
42592 }
42593 return resultobj;
42594 fail:
42595 {
42596 if (temp4)
42597 delete arg4;
42598 }
42599 {
42600 if (temp5)
42601 delete arg5;
42602 }
42603 return NULL;
42604 }
42605
42606
42607 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42608 PyObject *resultobj = 0;
42609 wxMenu *arg1 = (wxMenu *) 0 ;
42610 size_t arg2 ;
42611 int arg3 ;
42612 wxString *arg4 = 0 ;
42613 wxMenu *arg5 = (wxMenu *) 0 ;
42614 wxString const &arg6_defvalue = wxPyEmptyString ;
42615 wxString *arg6 = (wxString *) &arg6_defvalue ;
42616 wxMenuItem *result = 0 ;
42617 void *argp1 = 0 ;
42618 int res1 = 0 ;
42619 size_t val2 ;
42620 int ecode2 = 0 ;
42621 int val3 ;
42622 int ecode3 = 0 ;
42623 bool temp4 = false ;
42624 void *argp5 = 0 ;
42625 int res5 = 0 ;
42626 bool temp6 = false ;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629 PyObject * obj2 = 0 ;
42630 PyObject * obj3 = 0 ;
42631 PyObject * obj4 = 0 ;
42632 PyObject * obj5 = 0 ;
42633 char * kwnames[] = {
42634 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42635 };
42636
42637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenu * >(argp1);
42643 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42644 if (!SWIG_IsOK(ecode2)) {
42645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42646 }
42647 arg2 = static_cast< size_t >(val2);
42648 ecode3 = SWIG_AsVal_int(obj2, &val3);
42649 if (!SWIG_IsOK(ecode3)) {
42650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42651 }
42652 arg3 = static_cast< int >(val3);
42653 {
42654 arg4 = wxString_in_helper(obj3);
42655 if (arg4 == NULL) SWIG_fail;
42656 temp4 = true;
42657 }
42658 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42659 if (!SWIG_IsOK(res5)) {
42660 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42661 }
42662 arg5 = reinterpret_cast< wxMenu * >(argp5);
42663 if (obj5) {
42664 {
42665 arg6 = wxString_in_helper(obj5);
42666 if (arg6 == NULL) SWIG_fail;
42667 temp6 = true;
42668 }
42669 }
42670 {
42671 PyThreadState* __tstate = wxPyBeginAllowThreads();
42672 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42673 wxPyEndAllowThreads(__tstate);
42674 if (PyErr_Occurred()) SWIG_fail;
42675 }
42676 {
42677 resultobj = wxPyMake_wxObject(result, (bool)0);
42678 }
42679 {
42680 if (temp4)
42681 delete arg4;
42682 }
42683 {
42684 if (temp6)
42685 delete arg6;
42686 }
42687 return resultobj;
42688 fail:
42689 {
42690 if (temp4)
42691 delete arg4;
42692 }
42693 {
42694 if (temp6)
42695 delete arg6;
42696 }
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj = 0;
42703 wxMenu *arg1 = (wxMenu *) 0 ;
42704 int arg2 ;
42705 wxString const &arg3_defvalue = wxPyEmptyString ;
42706 wxString *arg3 = (wxString *) &arg3_defvalue ;
42707 wxString const &arg4_defvalue = wxPyEmptyString ;
42708 wxString *arg4 = (wxString *) &arg4_defvalue ;
42709 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42710 wxMenuItem *result = 0 ;
42711 void *argp1 = 0 ;
42712 int res1 = 0 ;
42713 int val2 ;
42714 int ecode2 = 0 ;
42715 bool temp3 = false ;
42716 bool temp4 = false ;
42717 int val5 ;
42718 int ecode5 = 0 ;
42719 PyObject * obj0 = 0 ;
42720 PyObject * obj1 = 0 ;
42721 PyObject * obj2 = 0 ;
42722 PyObject * obj3 = 0 ;
42723 PyObject * obj4 = 0 ;
42724 char * kwnames[] = {
42725 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42726 };
42727
42728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42730 if (!SWIG_IsOK(res1)) {
42731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42732 }
42733 arg1 = reinterpret_cast< wxMenu * >(argp1);
42734 ecode2 = SWIG_AsVal_int(obj1, &val2);
42735 if (!SWIG_IsOK(ecode2)) {
42736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42737 }
42738 arg2 = static_cast< int >(val2);
42739 if (obj2) {
42740 {
42741 arg3 = wxString_in_helper(obj2);
42742 if (arg3 == NULL) SWIG_fail;
42743 temp3 = true;
42744 }
42745 }
42746 if (obj3) {
42747 {
42748 arg4 = wxString_in_helper(obj3);
42749 if (arg4 == NULL) SWIG_fail;
42750 temp4 = true;
42751 }
42752 }
42753 if (obj4) {
42754 ecode5 = SWIG_AsVal_int(obj4, &val5);
42755 if (!SWIG_IsOK(ecode5)) {
42756 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42757 }
42758 arg5 = static_cast< wxItemKind >(val5);
42759 }
42760 {
42761 PyThreadState* __tstate = wxPyBeginAllowThreads();
42762 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42763 wxPyEndAllowThreads(__tstate);
42764 if (PyErr_Occurred()) SWIG_fail;
42765 }
42766 {
42767 resultobj = wxPyMake_wxObject(result, (bool)0);
42768 }
42769 {
42770 if (temp3)
42771 delete arg3;
42772 }
42773 {
42774 if (temp4)
42775 delete arg4;
42776 }
42777 return resultobj;
42778 fail:
42779 {
42780 if (temp3)
42781 delete arg3;
42782 }
42783 {
42784 if (temp4)
42785 delete arg4;
42786 }
42787 return NULL;
42788 }
42789
42790
42791 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42792 PyObject *resultobj = 0;
42793 wxMenu *arg1 = (wxMenu *) 0 ;
42794 wxMenuItem *result = 0 ;
42795 void *argp1 = 0 ;
42796 int res1 = 0 ;
42797 PyObject *swig_obj[1] ;
42798
42799 if (!args) SWIG_fail;
42800 swig_obj[0] = args;
42801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42802 if (!SWIG_IsOK(res1)) {
42803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42804 }
42805 arg1 = reinterpret_cast< wxMenu * >(argp1);
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 result = (wxMenuItem *)(arg1)->PrependSeparator();
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 {
42813 resultobj = wxPyMake_wxObject(result, (bool)0);
42814 }
42815 return resultobj;
42816 fail:
42817 return NULL;
42818 }
42819
42820
42821 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42822 PyObject *resultobj = 0;
42823 wxMenu *arg1 = (wxMenu *) 0 ;
42824 int arg2 ;
42825 wxString *arg3 = 0 ;
42826 wxString const &arg4_defvalue = wxPyEmptyString ;
42827 wxString *arg4 = (wxString *) &arg4_defvalue ;
42828 wxMenuItem *result = 0 ;
42829 void *argp1 = 0 ;
42830 int res1 = 0 ;
42831 int val2 ;
42832 int ecode2 = 0 ;
42833 bool temp3 = false ;
42834 bool temp4 = false ;
42835 PyObject * obj0 = 0 ;
42836 PyObject * obj1 = 0 ;
42837 PyObject * obj2 = 0 ;
42838 PyObject * obj3 = 0 ;
42839 char * kwnames[] = {
42840 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42841 };
42842
42843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42845 if (!SWIG_IsOK(res1)) {
42846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42847 }
42848 arg1 = reinterpret_cast< wxMenu * >(argp1);
42849 ecode2 = SWIG_AsVal_int(obj1, &val2);
42850 if (!SWIG_IsOK(ecode2)) {
42851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42852 }
42853 arg2 = static_cast< int >(val2);
42854 {
42855 arg3 = wxString_in_helper(obj2);
42856 if (arg3 == NULL) SWIG_fail;
42857 temp3 = true;
42858 }
42859 if (obj3) {
42860 {
42861 arg4 = wxString_in_helper(obj3);
42862 if (arg4 == NULL) SWIG_fail;
42863 temp4 = true;
42864 }
42865 }
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42869 wxPyEndAllowThreads(__tstate);
42870 if (PyErr_Occurred()) SWIG_fail;
42871 }
42872 {
42873 resultobj = wxPyMake_wxObject(result, (bool)0);
42874 }
42875 {
42876 if (temp3)
42877 delete arg3;
42878 }
42879 {
42880 if (temp4)
42881 delete arg4;
42882 }
42883 return resultobj;
42884 fail:
42885 {
42886 if (temp3)
42887 delete arg3;
42888 }
42889 {
42890 if (temp4)
42891 delete arg4;
42892 }
42893 return NULL;
42894 }
42895
42896
42897 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj = 0;
42899 wxMenu *arg1 = (wxMenu *) 0 ;
42900 int arg2 ;
42901 wxString *arg3 = 0 ;
42902 wxString const &arg4_defvalue = wxPyEmptyString ;
42903 wxString *arg4 = (wxString *) &arg4_defvalue ;
42904 wxMenuItem *result = 0 ;
42905 void *argp1 = 0 ;
42906 int res1 = 0 ;
42907 int val2 ;
42908 int ecode2 = 0 ;
42909 bool temp3 = false ;
42910 bool temp4 = false ;
42911 PyObject * obj0 = 0 ;
42912 PyObject * obj1 = 0 ;
42913 PyObject * obj2 = 0 ;
42914 PyObject * obj3 = 0 ;
42915 char * kwnames[] = {
42916 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42917 };
42918
42919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42921 if (!SWIG_IsOK(res1)) {
42922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42923 }
42924 arg1 = reinterpret_cast< wxMenu * >(argp1);
42925 ecode2 = SWIG_AsVal_int(obj1, &val2);
42926 if (!SWIG_IsOK(ecode2)) {
42927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42928 }
42929 arg2 = static_cast< int >(val2);
42930 {
42931 arg3 = wxString_in_helper(obj2);
42932 if (arg3 == NULL) SWIG_fail;
42933 temp3 = true;
42934 }
42935 if (obj3) {
42936 {
42937 arg4 = wxString_in_helper(obj3);
42938 if (arg4 == NULL) SWIG_fail;
42939 temp4 = true;
42940 }
42941 }
42942 {
42943 PyThreadState* __tstate = wxPyBeginAllowThreads();
42944 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42945 wxPyEndAllowThreads(__tstate);
42946 if (PyErr_Occurred()) SWIG_fail;
42947 }
42948 {
42949 resultobj = wxPyMake_wxObject(result, (bool)0);
42950 }
42951 {
42952 if (temp3)
42953 delete arg3;
42954 }
42955 {
42956 if (temp4)
42957 delete arg4;
42958 }
42959 return resultobj;
42960 fail:
42961 {
42962 if (temp3)
42963 delete arg3;
42964 }
42965 {
42966 if (temp4)
42967 delete arg4;
42968 }
42969 return NULL;
42970 }
42971
42972
42973 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42974 PyObject *resultobj = 0;
42975 wxMenu *arg1 = (wxMenu *) 0 ;
42976 int arg2 ;
42977 wxString *arg3 = 0 ;
42978 wxMenu *arg4 = (wxMenu *) 0 ;
42979 wxString const &arg5_defvalue = wxPyEmptyString ;
42980 wxString *arg5 = (wxString *) &arg5_defvalue ;
42981 wxMenuItem *result = 0 ;
42982 void *argp1 = 0 ;
42983 int res1 = 0 ;
42984 int val2 ;
42985 int ecode2 = 0 ;
42986 bool temp3 = false ;
42987 void *argp4 = 0 ;
42988 int res4 = 0 ;
42989 bool temp5 = false ;
42990 PyObject * obj0 = 0 ;
42991 PyObject * obj1 = 0 ;
42992 PyObject * obj2 = 0 ;
42993 PyObject * obj3 = 0 ;
42994 PyObject * obj4 = 0 ;
42995 char * kwnames[] = {
42996 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42997 };
42998
42999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43001 if (!SWIG_IsOK(res1)) {
43002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43003 }
43004 arg1 = reinterpret_cast< wxMenu * >(argp1);
43005 ecode2 = SWIG_AsVal_int(obj1, &val2);
43006 if (!SWIG_IsOK(ecode2)) {
43007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43008 }
43009 arg2 = static_cast< int >(val2);
43010 {
43011 arg3 = wxString_in_helper(obj2);
43012 if (arg3 == NULL) SWIG_fail;
43013 temp3 = true;
43014 }
43015 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43016 if (!SWIG_IsOK(res4)) {
43017 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43018 }
43019 arg4 = reinterpret_cast< wxMenu * >(argp4);
43020 if (obj4) {
43021 {
43022 arg5 = wxString_in_helper(obj4);
43023 if (arg5 == NULL) SWIG_fail;
43024 temp5 = true;
43025 }
43026 }
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43030 wxPyEndAllowThreads(__tstate);
43031 if (PyErr_Occurred()) SWIG_fail;
43032 }
43033 {
43034 resultobj = wxPyMake_wxObject(result, (bool)0);
43035 }
43036 {
43037 if (temp3)
43038 delete arg3;
43039 }
43040 {
43041 if (temp5)
43042 delete arg5;
43043 }
43044 return resultobj;
43045 fail:
43046 {
43047 if (temp3)
43048 delete arg3;
43049 }
43050 {
43051 if (temp5)
43052 delete arg5;
43053 }
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj = 0;
43060 wxMenu *arg1 = (wxMenu *) 0 ;
43061 int arg2 ;
43062 wxMenuItem *result = 0 ;
43063 void *argp1 = 0 ;
43064 int res1 = 0 ;
43065 int val2 ;
43066 int ecode2 = 0 ;
43067 PyObject * obj0 = 0 ;
43068 PyObject * obj1 = 0 ;
43069 char * kwnames[] = {
43070 (char *) "self",(char *) "id", NULL
43071 };
43072
43073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43075 if (!SWIG_IsOK(res1)) {
43076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43077 }
43078 arg1 = reinterpret_cast< wxMenu * >(argp1);
43079 ecode2 = SWIG_AsVal_int(obj1, &val2);
43080 if (!SWIG_IsOK(ecode2)) {
43081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43082 }
43083 arg2 = static_cast< int >(val2);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 result = (wxMenuItem *)(arg1)->Remove(arg2);
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 {
43091 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43092 }
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj = 0;
43101 wxMenu *arg1 = (wxMenu *) 0 ;
43102 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43103 wxMenuItem *result = 0 ;
43104 void *argp1 = 0 ;
43105 int res1 = 0 ;
43106 void *argp2 = 0 ;
43107 int res2 = 0 ;
43108 PyObject * obj0 = 0 ;
43109 PyObject * obj1 = 0 ;
43110 char * kwnames[] = {
43111 (char *) "self",(char *) "item", NULL
43112 };
43113
43114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43116 if (!SWIG_IsOK(res1)) {
43117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43118 }
43119 arg1 = reinterpret_cast< wxMenu * >(argp1);
43120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43121 if (!SWIG_IsOK(res2)) {
43122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43123 }
43124 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (wxMenuItem *)(arg1)->Remove(arg2);
43128 wxPyEndAllowThreads(__tstate);
43129 if (PyErr_Occurred()) SWIG_fail;
43130 }
43131 {
43132 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43133 }
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43141 PyObject *resultobj = 0;
43142 wxMenu *arg1 = (wxMenu *) 0 ;
43143 int arg2 ;
43144 bool result;
43145 void *argp1 = 0 ;
43146 int res1 = 0 ;
43147 int val2 ;
43148 int ecode2 = 0 ;
43149 PyObject * obj0 = 0 ;
43150 PyObject * obj1 = 0 ;
43151 char * kwnames[] = {
43152 (char *) "self",(char *) "id", NULL
43153 };
43154
43155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43157 if (!SWIG_IsOK(res1)) {
43158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43159 }
43160 arg1 = reinterpret_cast< wxMenu * >(argp1);
43161 ecode2 = SWIG_AsVal_int(obj1, &val2);
43162 if (!SWIG_IsOK(ecode2)) {
43163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43164 }
43165 arg2 = static_cast< int >(val2);
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 result = (bool)(arg1)->Delete(arg2);
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 {
43173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43182 PyObject *resultobj = 0;
43183 wxMenu *arg1 = (wxMenu *) 0 ;
43184 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43185 bool result;
43186 void *argp1 = 0 ;
43187 int res1 = 0 ;
43188 void *argp2 = 0 ;
43189 int res2 = 0 ;
43190 PyObject * obj0 = 0 ;
43191 PyObject * obj1 = 0 ;
43192 char * kwnames[] = {
43193 (char *) "self",(char *) "item", NULL
43194 };
43195
43196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43198 if (!SWIG_IsOK(res1)) {
43199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43200 }
43201 arg1 = reinterpret_cast< wxMenu * >(argp1);
43202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43203 if (!SWIG_IsOK(res2)) {
43204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43205 }
43206 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43207 {
43208 PyThreadState* __tstate = wxPyBeginAllowThreads();
43209 result = (bool)(arg1)->Delete(arg2);
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 {
43214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43215 }
43216 return resultobj;
43217 fail:
43218 return NULL;
43219 }
43220
43221
43222 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43223 PyObject *resultobj = 0;
43224 wxMenu *arg1 = (wxMenu *) 0 ;
43225 void *argp1 = 0 ;
43226 int res1 = 0 ;
43227 PyObject *swig_obj[1] ;
43228
43229 if (!args) SWIG_fail;
43230 swig_obj[0] = args;
43231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenu * >(argp1);
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 wxMenu_Destroy(arg1);
43239 wxPyEndAllowThreads(__tstate);
43240 if (PyErr_Occurred()) SWIG_fail;
43241 }
43242 resultobj = SWIG_Py_Void();
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43250 PyObject *resultobj = 0;
43251 wxMenu *arg1 = (wxMenu *) 0 ;
43252 int arg2 ;
43253 bool result;
43254 void *argp1 = 0 ;
43255 int res1 = 0 ;
43256 int val2 ;
43257 int ecode2 = 0 ;
43258 PyObject * obj0 = 0 ;
43259 PyObject * obj1 = 0 ;
43260 char * kwnames[] = {
43261 (char *) "self",(char *) "id", NULL
43262 };
43263
43264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43266 if (!SWIG_IsOK(res1)) {
43267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43268 }
43269 arg1 = reinterpret_cast< wxMenu * >(argp1);
43270 ecode2 = SWIG_AsVal_int(obj1, &val2);
43271 if (!SWIG_IsOK(ecode2)) {
43272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43273 }
43274 arg2 = static_cast< int >(val2);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 result = (bool)(arg1)->Destroy(arg2);
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 {
43282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43283 }
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = 0;
43292 wxMenu *arg1 = (wxMenu *) 0 ;
43293 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43294 bool result;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 void *argp2 = 0 ;
43298 int res2 = 0 ;
43299 PyObject * obj0 = 0 ;
43300 PyObject * obj1 = 0 ;
43301 char * kwnames[] = {
43302 (char *) "self",(char *) "item", NULL
43303 };
43304
43305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43307 if (!SWIG_IsOK(res1)) {
43308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43309 }
43310 arg1 = reinterpret_cast< wxMenu * >(argp1);
43311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43312 if (!SWIG_IsOK(res2)) {
43313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43314 }
43315 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (bool)(arg1)->Destroy(arg2);
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 {
43323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43324 }
43325 return resultobj;
43326 fail:
43327 return NULL;
43328 }
43329
43330
43331 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43332 PyObject *resultobj = 0;
43333 wxMenu *arg1 = (wxMenu *) 0 ;
43334 size_t result;
43335 void *argp1 = 0 ;
43336 int res1 = 0 ;
43337 PyObject *swig_obj[1] ;
43338
43339 if (!args) SWIG_fail;
43340 swig_obj[0] = args;
43341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43342 if (!SWIG_IsOK(res1)) {
43343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43344 }
43345 arg1 = reinterpret_cast< wxMenu * >(argp1);
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43353 return resultobj;
43354 fail:
43355 return NULL;
43356 }
43357
43358
43359 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43360 PyObject *resultobj = 0;
43361 wxMenu *arg1 = (wxMenu *) 0 ;
43362 PyObject *result = 0 ;
43363 void *argp1 = 0 ;
43364 int res1 = 0 ;
43365 PyObject *swig_obj[1] ;
43366
43367 if (!args) SWIG_fail;
43368 swig_obj[0] = args;
43369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43370 if (!SWIG_IsOK(res1)) {
43371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43372 }
43373 arg1 = reinterpret_cast< wxMenu * >(argp1);
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = result;
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43388 PyObject *resultobj = 0;
43389 wxMenu *arg1 = (wxMenu *) 0 ;
43390 wxString *arg2 = 0 ;
43391 int result;
43392 void *argp1 = 0 ;
43393 int res1 = 0 ;
43394 bool temp2 = false ;
43395 PyObject * obj0 = 0 ;
43396 PyObject * obj1 = 0 ;
43397 char * kwnames[] = {
43398 (char *) "self",(char *) "item", NULL
43399 };
43400
43401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43403 if (!SWIG_IsOK(res1)) {
43404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43405 }
43406 arg1 = reinterpret_cast< wxMenu * >(argp1);
43407 {
43408 arg2 = wxString_in_helper(obj1);
43409 if (arg2 == NULL) SWIG_fail;
43410 temp2 = true;
43411 }
43412 {
43413 PyThreadState* __tstate = wxPyBeginAllowThreads();
43414 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 resultobj = SWIG_From_int(static_cast< int >(result));
43419 {
43420 if (temp2)
43421 delete arg2;
43422 }
43423 return resultobj;
43424 fail:
43425 {
43426 if (temp2)
43427 delete arg2;
43428 }
43429 return NULL;
43430 }
43431
43432
43433 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43434 PyObject *resultobj = 0;
43435 wxMenu *arg1 = (wxMenu *) 0 ;
43436 int arg2 ;
43437 wxMenuItem *result = 0 ;
43438 void *argp1 = 0 ;
43439 int res1 = 0 ;
43440 int val2 ;
43441 int ecode2 = 0 ;
43442 PyObject * obj0 = 0 ;
43443 PyObject * obj1 = 0 ;
43444 char * kwnames[] = {
43445 (char *) "self",(char *) "id", NULL
43446 };
43447
43448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43450 if (!SWIG_IsOK(res1)) {
43451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43452 }
43453 arg1 = reinterpret_cast< wxMenu * >(argp1);
43454 ecode2 = SWIG_AsVal_int(obj1, &val2);
43455 if (!SWIG_IsOK(ecode2)) {
43456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43457 }
43458 arg2 = static_cast< int >(val2);
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 {
43466 resultobj = wxPyMake_wxObject(result, (bool)0);
43467 }
43468 return resultobj;
43469 fail:
43470 return NULL;
43471 }
43472
43473
43474 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43475 PyObject *resultobj = 0;
43476 wxMenu *arg1 = (wxMenu *) 0 ;
43477 size_t arg2 ;
43478 wxMenuItem *result = 0 ;
43479 void *argp1 = 0 ;
43480 int res1 = 0 ;
43481 size_t val2 ;
43482 int ecode2 = 0 ;
43483 PyObject * obj0 = 0 ;
43484 PyObject * obj1 = 0 ;
43485 char * kwnames[] = {
43486 (char *) "self",(char *) "position", NULL
43487 };
43488
43489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43491 if (!SWIG_IsOK(res1)) {
43492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43493 }
43494 arg1 = reinterpret_cast< wxMenu * >(argp1);
43495 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43496 if (!SWIG_IsOK(ecode2)) {
43497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43498 }
43499 arg2 = static_cast< size_t >(val2);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 {
43507 resultobj = wxPyMake_wxObject(result, (bool)0);
43508 }
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = 0;
43517 wxMenu *arg1 = (wxMenu *) 0 ;
43518 int arg2 ;
43519 bool arg3 ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 int val2 ;
43523 int ecode2 = 0 ;
43524 bool val3 ;
43525 int ecode3 = 0 ;
43526 PyObject * obj0 = 0 ;
43527 PyObject * obj1 = 0 ;
43528 PyObject * obj2 = 0 ;
43529 char * kwnames[] = {
43530 (char *) "self",(char *) "id",(char *) "enable", NULL
43531 };
43532
43533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43535 if (!SWIG_IsOK(res1)) {
43536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43537 }
43538 arg1 = reinterpret_cast< wxMenu * >(argp1);
43539 ecode2 = SWIG_AsVal_int(obj1, &val2);
43540 if (!SWIG_IsOK(ecode2)) {
43541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43542 }
43543 arg2 = static_cast< int >(val2);
43544 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43545 if (!SWIG_IsOK(ecode3)) {
43546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43547 }
43548 arg3 = static_cast< bool >(val3);
43549 {
43550 PyThreadState* __tstate = wxPyBeginAllowThreads();
43551 (arg1)->Enable(arg2,arg3);
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 resultobj = SWIG_Py_Void();
43556 return resultobj;
43557 fail:
43558 return NULL;
43559 }
43560
43561
43562 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43563 PyObject *resultobj = 0;
43564 wxMenu *arg1 = (wxMenu *) 0 ;
43565 int arg2 ;
43566 bool result;
43567 void *argp1 = 0 ;
43568 int res1 = 0 ;
43569 int val2 ;
43570 int ecode2 = 0 ;
43571 PyObject * obj0 = 0 ;
43572 PyObject * obj1 = 0 ;
43573 char * kwnames[] = {
43574 (char *) "self",(char *) "id", NULL
43575 };
43576
43577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43579 if (!SWIG_IsOK(res1)) {
43580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43581 }
43582 arg1 = reinterpret_cast< wxMenu * >(argp1);
43583 ecode2 = SWIG_AsVal_int(obj1, &val2);
43584 if (!SWIG_IsOK(ecode2)) {
43585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43586 }
43587 arg2 = static_cast< int >(val2);
43588 {
43589 PyThreadState* __tstate = wxPyBeginAllowThreads();
43590 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43596 }
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj = 0;
43605 wxMenu *arg1 = (wxMenu *) 0 ;
43606 int arg2 ;
43607 bool arg3 ;
43608 void *argp1 = 0 ;
43609 int res1 = 0 ;
43610 int val2 ;
43611 int ecode2 = 0 ;
43612 bool val3 ;
43613 int ecode3 = 0 ;
43614 PyObject * obj0 = 0 ;
43615 PyObject * obj1 = 0 ;
43616 PyObject * obj2 = 0 ;
43617 char * kwnames[] = {
43618 (char *) "self",(char *) "id",(char *) "check", NULL
43619 };
43620
43621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenu * >(argp1);
43627 ecode2 = SWIG_AsVal_int(obj1, &val2);
43628 if (!SWIG_IsOK(ecode2)) {
43629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43630 }
43631 arg2 = static_cast< int >(val2);
43632 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43633 if (!SWIG_IsOK(ecode3)) {
43634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43635 }
43636 arg3 = static_cast< bool >(val3);
43637 {
43638 PyThreadState* __tstate = wxPyBeginAllowThreads();
43639 (arg1)->Check(arg2,arg3);
43640 wxPyEndAllowThreads(__tstate);
43641 if (PyErr_Occurred()) SWIG_fail;
43642 }
43643 resultobj = SWIG_Py_Void();
43644 return resultobj;
43645 fail:
43646 return NULL;
43647 }
43648
43649
43650 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43651 PyObject *resultobj = 0;
43652 wxMenu *arg1 = (wxMenu *) 0 ;
43653 int arg2 ;
43654 bool result;
43655 void *argp1 = 0 ;
43656 int res1 = 0 ;
43657 int val2 ;
43658 int ecode2 = 0 ;
43659 PyObject * obj0 = 0 ;
43660 PyObject * obj1 = 0 ;
43661 char * kwnames[] = {
43662 (char *) "self",(char *) "id", NULL
43663 };
43664
43665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43667 if (!SWIG_IsOK(res1)) {
43668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43669 }
43670 arg1 = reinterpret_cast< wxMenu * >(argp1);
43671 ecode2 = SWIG_AsVal_int(obj1, &val2);
43672 if (!SWIG_IsOK(ecode2)) {
43673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43674 }
43675 arg2 = static_cast< int >(val2);
43676 {
43677 PyThreadState* __tstate = wxPyBeginAllowThreads();
43678 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43679 wxPyEndAllowThreads(__tstate);
43680 if (PyErr_Occurred()) SWIG_fail;
43681 }
43682 {
43683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43684 }
43685 return resultobj;
43686 fail:
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43692 PyObject *resultobj = 0;
43693 wxMenu *arg1 = (wxMenu *) 0 ;
43694 int arg2 ;
43695 wxString *arg3 = 0 ;
43696 void *argp1 = 0 ;
43697 int res1 = 0 ;
43698 int val2 ;
43699 int ecode2 = 0 ;
43700 bool temp3 = false ;
43701 PyObject * obj0 = 0 ;
43702 PyObject * obj1 = 0 ;
43703 PyObject * obj2 = 0 ;
43704 char * kwnames[] = {
43705 (char *) "self",(char *) "id",(char *) "label", NULL
43706 };
43707
43708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43710 if (!SWIG_IsOK(res1)) {
43711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43712 }
43713 arg1 = reinterpret_cast< wxMenu * >(argp1);
43714 ecode2 = SWIG_AsVal_int(obj1, &val2);
43715 if (!SWIG_IsOK(ecode2)) {
43716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43717 }
43718 arg2 = static_cast< int >(val2);
43719 {
43720 arg3 = wxString_in_helper(obj2);
43721 if (arg3 == NULL) SWIG_fail;
43722 temp3 = true;
43723 }
43724 {
43725 PyThreadState* __tstate = wxPyBeginAllowThreads();
43726 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43727 wxPyEndAllowThreads(__tstate);
43728 if (PyErr_Occurred()) SWIG_fail;
43729 }
43730 resultobj = SWIG_Py_Void();
43731 {
43732 if (temp3)
43733 delete arg3;
43734 }
43735 return resultobj;
43736 fail:
43737 {
43738 if (temp3)
43739 delete arg3;
43740 }
43741 return NULL;
43742 }
43743
43744
43745 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43746 PyObject *resultobj = 0;
43747 wxMenu *arg1 = (wxMenu *) 0 ;
43748 int arg2 ;
43749 wxString result;
43750 void *argp1 = 0 ;
43751 int res1 = 0 ;
43752 int val2 ;
43753 int ecode2 = 0 ;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756 char * kwnames[] = {
43757 (char *) "self",(char *) "id", NULL
43758 };
43759
43760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenu * >(argp1);
43766 ecode2 = SWIG_AsVal_int(obj1, &val2);
43767 if (!SWIG_IsOK(ecode2)) {
43768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43769 }
43770 arg2 = static_cast< int >(val2);
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43774 wxPyEndAllowThreads(__tstate);
43775 if (PyErr_Occurred()) SWIG_fail;
43776 }
43777 {
43778 #if wxUSE_UNICODE
43779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43780 #else
43781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43782 #endif
43783 }
43784 return resultobj;
43785 fail:
43786 return NULL;
43787 }
43788
43789
43790 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43791 PyObject *resultobj = 0;
43792 wxMenu *arg1 = (wxMenu *) 0 ;
43793 int arg2 ;
43794 wxString *arg3 = 0 ;
43795 void *argp1 = 0 ;
43796 int res1 = 0 ;
43797 int val2 ;
43798 int ecode2 = 0 ;
43799 bool temp3 = false ;
43800 PyObject * obj0 = 0 ;
43801 PyObject * obj1 = 0 ;
43802 PyObject * obj2 = 0 ;
43803 char * kwnames[] = {
43804 (char *) "self",(char *) "id",(char *) "helpString", NULL
43805 };
43806
43807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenu * >(argp1);
43813 ecode2 = SWIG_AsVal_int(obj1, &val2);
43814 if (!SWIG_IsOK(ecode2)) {
43815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43816 }
43817 arg2 = static_cast< int >(val2);
43818 {
43819 arg3 = wxString_in_helper(obj2);
43820 if (arg3 == NULL) SWIG_fail;
43821 temp3 = true;
43822 }
43823 {
43824 PyThreadState* __tstate = wxPyBeginAllowThreads();
43825 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 resultobj = SWIG_Py_Void();
43830 {
43831 if (temp3)
43832 delete arg3;
43833 }
43834 return resultobj;
43835 fail:
43836 {
43837 if (temp3)
43838 delete arg3;
43839 }
43840 return NULL;
43841 }
43842
43843
43844 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43845 PyObject *resultobj = 0;
43846 wxMenu *arg1 = (wxMenu *) 0 ;
43847 int arg2 ;
43848 wxString result;
43849 void *argp1 = 0 ;
43850 int res1 = 0 ;
43851 int val2 ;
43852 int ecode2 = 0 ;
43853 PyObject * obj0 = 0 ;
43854 PyObject * obj1 = 0 ;
43855 char * kwnames[] = {
43856 (char *) "self",(char *) "id", NULL
43857 };
43858
43859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43861 if (!SWIG_IsOK(res1)) {
43862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43863 }
43864 arg1 = reinterpret_cast< wxMenu * >(argp1);
43865 ecode2 = SWIG_AsVal_int(obj1, &val2);
43866 if (!SWIG_IsOK(ecode2)) {
43867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43868 }
43869 arg2 = static_cast< int >(val2);
43870 {
43871 PyThreadState* __tstate = wxPyBeginAllowThreads();
43872 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 {
43877 #if wxUSE_UNICODE
43878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43879 #else
43880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43881 #endif
43882 }
43883 return resultobj;
43884 fail:
43885 return NULL;
43886 }
43887
43888
43889 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43890 PyObject *resultobj = 0;
43891 wxMenu *arg1 = (wxMenu *) 0 ;
43892 wxString *arg2 = 0 ;
43893 void *argp1 = 0 ;
43894 int res1 = 0 ;
43895 bool temp2 = false ;
43896 PyObject * obj0 = 0 ;
43897 PyObject * obj1 = 0 ;
43898 char * kwnames[] = {
43899 (char *) "self",(char *) "title", NULL
43900 };
43901
43902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43904 if (!SWIG_IsOK(res1)) {
43905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43906 }
43907 arg1 = reinterpret_cast< wxMenu * >(argp1);
43908 {
43909 arg2 = wxString_in_helper(obj1);
43910 if (arg2 == NULL) SWIG_fail;
43911 temp2 = true;
43912 }
43913 {
43914 PyThreadState* __tstate = wxPyBeginAllowThreads();
43915 (arg1)->SetTitle((wxString const &)*arg2);
43916 wxPyEndAllowThreads(__tstate);
43917 if (PyErr_Occurred()) SWIG_fail;
43918 }
43919 resultobj = SWIG_Py_Void();
43920 {
43921 if (temp2)
43922 delete arg2;
43923 }
43924 return resultobj;
43925 fail:
43926 {
43927 if (temp2)
43928 delete arg2;
43929 }
43930 return NULL;
43931 }
43932
43933
43934 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43935 PyObject *resultobj = 0;
43936 wxMenu *arg1 = (wxMenu *) 0 ;
43937 wxString result;
43938 void *argp1 = 0 ;
43939 int res1 = 0 ;
43940 PyObject *swig_obj[1] ;
43941
43942 if (!args) SWIG_fail;
43943 swig_obj[0] = args;
43944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43945 if (!SWIG_IsOK(res1)) {
43946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43947 }
43948 arg1 = reinterpret_cast< wxMenu * >(argp1);
43949 {
43950 PyThreadState* __tstate = wxPyBeginAllowThreads();
43951 result = ((wxMenu const *)arg1)->GetTitle();
43952 wxPyEndAllowThreads(__tstate);
43953 if (PyErr_Occurred()) SWIG_fail;
43954 }
43955 {
43956 #if wxUSE_UNICODE
43957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43958 #else
43959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43960 #endif
43961 }
43962 return resultobj;
43963 fail:
43964 return NULL;
43965 }
43966
43967
43968 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43969 PyObject *resultobj = 0;
43970 wxMenu *arg1 = (wxMenu *) 0 ;
43971 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 void *argp2 = 0 ;
43975 int res2 = 0 ;
43976 PyObject * obj0 = 0 ;
43977 PyObject * obj1 = 0 ;
43978 char * kwnames[] = {
43979 (char *) "self",(char *) "handler", NULL
43980 };
43981
43982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43984 if (!SWIG_IsOK(res1)) {
43985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43986 }
43987 arg1 = reinterpret_cast< wxMenu * >(argp1);
43988 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43989 if (!SWIG_IsOK(res2)) {
43990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43991 }
43992 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43993 {
43994 PyThreadState* __tstate = wxPyBeginAllowThreads();
43995 (arg1)->SetEventHandler(arg2);
43996 wxPyEndAllowThreads(__tstate);
43997 if (PyErr_Occurred()) SWIG_fail;
43998 }
43999 resultobj = SWIG_Py_Void();
44000 return resultobj;
44001 fail:
44002 return NULL;
44003 }
44004
44005
44006 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44007 PyObject *resultobj = 0;
44008 wxMenu *arg1 = (wxMenu *) 0 ;
44009 wxEvtHandler *result = 0 ;
44010 void *argp1 = 0 ;
44011 int res1 = 0 ;
44012 PyObject *swig_obj[1] ;
44013
44014 if (!args) SWIG_fail;
44015 swig_obj[0] = args;
44016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44017 if (!SWIG_IsOK(res1)) {
44018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44019 }
44020 arg1 = reinterpret_cast< wxMenu * >(argp1);
44021 {
44022 PyThreadState* __tstate = wxPyBeginAllowThreads();
44023 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44024 wxPyEndAllowThreads(__tstate);
44025 if (PyErr_Occurred()) SWIG_fail;
44026 }
44027 {
44028 resultobj = wxPyMake_wxObject(result, 0);
44029 }
44030 return resultobj;
44031 fail:
44032 return NULL;
44033 }
44034
44035
44036 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44037 PyObject *resultobj = 0;
44038 wxMenu *arg1 = (wxMenu *) 0 ;
44039 wxWindow *arg2 = (wxWindow *) 0 ;
44040 void *argp1 = 0 ;
44041 int res1 = 0 ;
44042 void *argp2 = 0 ;
44043 int res2 = 0 ;
44044 PyObject * obj0 = 0 ;
44045 PyObject * obj1 = 0 ;
44046 char * kwnames[] = {
44047 (char *) "self",(char *) "win", NULL
44048 };
44049
44050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44052 if (!SWIG_IsOK(res1)) {
44053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44054 }
44055 arg1 = reinterpret_cast< wxMenu * >(argp1);
44056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44057 if (!SWIG_IsOK(res2)) {
44058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44059 }
44060 arg2 = reinterpret_cast< wxWindow * >(argp2);
44061 {
44062 PyThreadState* __tstate = wxPyBeginAllowThreads();
44063 (arg1)->SetInvokingWindow(arg2);
44064 wxPyEndAllowThreads(__tstate);
44065 if (PyErr_Occurred()) SWIG_fail;
44066 }
44067 resultobj = SWIG_Py_Void();
44068 return resultobj;
44069 fail:
44070 return NULL;
44071 }
44072
44073
44074 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44075 PyObject *resultobj = 0;
44076 wxMenu *arg1 = (wxMenu *) 0 ;
44077 wxWindow *result = 0 ;
44078 void *argp1 = 0 ;
44079 int res1 = 0 ;
44080 PyObject *swig_obj[1] ;
44081
44082 if (!args) SWIG_fail;
44083 swig_obj[0] = args;
44084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44085 if (!SWIG_IsOK(res1)) {
44086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44087 }
44088 arg1 = reinterpret_cast< wxMenu * >(argp1);
44089 {
44090 PyThreadState* __tstate = wxPyBeginAllowThreads();
44091 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44092 wxPyEndAllowThreads(__tstate);
44093 if (PyErr_Occurred()) SWIG_fail;
44094 }
44095 {
44096 resultobj = wxPyMake_wxObject(result, 0);
44097 }
44098 return resultobj;
44099 fail:
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44105 PyObject *resultobj = 0;
44106 wxMenu *arg1 = (wxMenu *) 0 ;
44107 long result;
44108 void *argp1 = 0 ;
44109 int res1 = 0 ;
44110 PyObject *swig_obj[1] ;
44111
44112 if (!args) SWIG_fail;
44113 swig_obj[0] = args;
44114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44115 if (!SWIG_IsOK(res1)) {
44116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44117 }
44118 arg1 = reinterpret_cast< wxMenu * >(argp1);
44119 {
44120 PyThreadState* __tstate = wxPyBeginAllowThreads();
44121 result = (long)((wxMenu const *)arg1)->GetStyle();
44122 wxPyEndAllowThreads(__tstate);
44123 if (PyErr_Occurred()) SWIG_fail;
44124 }
44125 resultobj = SWIG_From_long(static_cast< long >(result));
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44133 PyObject *resultobj = 0;
44134 wxMenu *arg1 = (wxMenu *) 0 ;
44135 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44136 void *argp1 = 0 ;
44137 int res1 = 0 ;
44138 void *argp2 = 0 ;
44139 int res2 = 0 ;
44140 PyObject * obj0 = 0 ;
44141 PyObject * obj1 = 0 ;
44142 char * kwnames[] = {
44143 (char *) "self",(char *) "source", NULL
44144 };
44145
44146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44148 if (!SWIG_IsOK(res1)) {
44149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44150 }
44151 arg1 = reinterpret_cast< wxMenu * >(argp1);
44152 if (obj1) {
44153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44154 if (!SWIG_IsOK(res2)) {
44155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44156 }
44157 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44158 }
44159 {
44160 PyThreadState* __tstate = wxPyBeginAllowThreads();
44161 (arg1)->UpdateUI(arg2);
44162 wxPyEndAllowThreads(__tstate);
44163 if (PyErr_Occurred()) SWIG_fail;
44164 }
44165 resultobj = SWIG_Py_Void();
44166 return resultobj;
44167 fail:
44168 return NULL;
44169 }
44170
44171
44172 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44173 PyObject *resultobj = 0;
44174 wxMenu *arg1 = (wxMenu *) 0 ;
44175 wxMenuBar *result = 0 ;
44176 void *argp1 = 0 ;
44177 int res1 = 0 ;
44178 PyObject *swig_obj[1] ;
44179
44180 if (!args) SWIG_fail;
44181 swig_obj[0] = args;
44182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44183 if (!SWIG_IsOK(res1)) {
44184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44185 }
44186 arg1 = reinterpret_cast< wxMenu * >(argp1);
44187 {
44188 PyThreadState* __tstate = wxPyBeginAllowThreads();
44189 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44190 wxPyEndAllowThreads(__tstate);
44191 if (PyErr_Occurred()) SWIG_fail;
44192 }
44193 {
44194 resultobj = wxPyMake_wxObject(result, (bool)0);
44195 }
44196 return resultobj;
44197 fail:
44198 return NULL;
44199 }
44200
44201
44202 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44203 PyObject *resultobj = 0;
44204 wxMenu *arg1 = (wxMenu *) 0 ;
44205 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44206 void *argp1 = 0 ;
44207 int res1 = 0 ;
44208 void *argp2 = 0 ;
44209 int res2 = 0 ;
44210 PyObject * obj0 = 0 ;
44211 PyObject * obj1 = 0 ;
44212 char * kwnames[] = {
44213 (char *) "self",(char *) "menubar", NULL
44214 };
44215
44216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44218 if (!SWIG_IsOK(res1)) {
44219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44220 }
44221 arg1 = reinterpret_cast< wxMenu * >(argp1);
44222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44223 if (!SWIG_IsOK(res2)) {
44224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44225 }
44226 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44227 {
44228 PyThreadState* __tstate = wxPyBeginAllowThreads();
44229 (arg1)->Attach(arg2);
44230 wxPyEndAllowThreads(__tstate);
44231 if (PyErr_Occurred()) SWIG_fail;
44232 }
44233 resultobj = SWIG_Py_Void();
44234 return resultobj;
44235 fail:
44236 return NULL;
44237 }
44238
44239
44240 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44241 PyObject *resultobj = 0;
44242 wxMenu *arg1 = (wxMenu *) 0 ;
44243 void *argp1 = 0 ;
44244 int res1 = 0 ;
44245 PyObject *swig_obj[1] ;
44246
44247 if (!args) SWIG_fail;
44248 swig_obj[0] = args;
44249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44250 if (!SWIG_IsOK(res1)) {
44251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44252 }
44253 arg1 = reinterpret_cast< wxMenu * >(argp1);
44254 {
44255 PyThreadState* __tstate = wxPyBeginAllowThreads();
44256 (arg1)->Detach();
44257 wxPyEndAllowThreads(__tstate);
44258 if (PyErr_Occurred()) SWIG_fail;
44259 }
44260 resultobj = SWIG_Py_Void();
44261 return resultobj;
44262 fail:
44263 return NULL;
44264 }
44265
44266
44267 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44268 PyObject *resultobj = 0;
44269 wxMenu *arg1 = (wxMenu *) 0 ;
44270 bool result;
44271 void *argp1 = 0 ;
44272 int res1 = 0 ;
44273 PyObject *swig_obj[1] ;
44274
44275 if (!args) SWIG_fail;
44276 swig_obj[0] = args;
44277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44278 if (!SWIG_IsOK(res1)) {
44279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44280 }
44281 arg1 = reinterpret_cast< wxMenu * >(argp1);
44282 {
44283 PyThreadState* __tstate = wxPyBeginAllowThreads();
44284 result = (bool)((wxMenu const *)arg1)->IsAttached();
44285 wxPyEndAllowThreads(__tstate);
44286 if (PyErr_Occurred()) SWIG_fail;
44287 }
44288 {
44289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44290 }
44291 return resultobj;
44292 fail:
44293 return NULL;
44294 }
44295
44296
44297 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44298 PyObject *resultobj = 0;
44299 wxMenu *arg1 = (wxMenu *) 0 ;
44300 wxMenu *arg2 = (wxMenu *) 0 ;
44301 void *argp1 = 0 ;
44302 int res1 = 0 ;
44303 void *argp2 = 0 ;
44304 int res2 = 0 ;
44305 PyObject * obj0 = 0 ;
44306 PyObject * obj1 = 0 ;
44307 char * kwnames[] = {
44308 (char *) "self",(char *) "parent", NULL
44309 };
44310
44311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44313 if (!SWIG_IsOK(res1)) {
44314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44315 }
44316 arg1 = reinterpret_cast< wxMenu * >(argp1);
44317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44318 if (!SWIG_IsOK(res2)) {
44319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44320 }
44321 arg2 = reinterpret_cast< wxMenu * >(argp2);
44322 {
44323 PyThreadState* __tstate = wxPyBeginAllowThreads();
44324 (arg1)->SetParent(arg2);
44325 wxPyEndAllowThreads(__tstate);
44326 if (PyErr_Occurred()) SWIG_fail;
44327 }
44328 resultobj = SWIG_Py_Void();
44329 return resultobj;
44330 fail:
44331 return NULL;
44332 }
44333
44334
44335 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44336 PyObject *resultobj = 0;
44337 wxMenu *arg1 = (wxMenu *) 0 ;
44338 wxMenu *result = 0 ;
44339 void *argp1 = 0 ;
44340 int res1 = 0 ;
44341 PyObject *swig_obj[1] ;
44342
44343 if (!args) SWIG_fail;
44344 swig_obj[0] = args;
44345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44346 if (!SWIG_IsOK(res1)) {
44347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44348 }
44349 arg1 = reinterpret_cast< wxMenu * >(argp1);
44350 {
44351 PyThreadState* __tstate = wxPyBeginAllowThreads();
44352 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44353 wxPyEndAllowThreads(__tstate);
44354 if (PyErr_Occurred()) SWIG_fail;
44355 }
44356 {
44357 resultobj = wxPyMake_wxObject(result, 0);
44358 }
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44366 PyObject *obj;
44367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44368 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44369 return SWIG_Py_Void();
44370 }
44371
44372 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44373 return SWIG_Python_InitShadowInstance(args);
44374 }
44375
44376 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44377 PyObject *resultobj = 0;
44378 long arg1 = (long) 0 ;
44379 wxMenuBar *result = 0 ;
44380 long val1 ;
44381 int ecode1 = 0 ;
44382 PyObject * obj0 = 0 ;
44383 char * kwnames[] = {
44384 (char *) "style", NULL
44385 };
44386
44387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44388 if (obj0) {
44389 ecode1 = SWIG_AsVal_long(obj0, &val1);
44390 if (!SWIG_IsOK(ecode1)) {
44391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44392 }
44393 arg1 = static_cast< long >(val1);
44394 }
44395 {
44396 if (!wxPyCheckForApp()) SWIG_fail;
44397 PyThreadState* __tstate = wxPyBeginAllowThreads();
44398 result = (wxMenuBar *)new wxMenuBar(arg1);
44399 wxPyEndAllowThreads(__tstate);
44400 if (PyErr_Occurred()) SWIG_fail;
44401 }
44402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44403 return resultobj;
44404 fail:
44405 return NULL;
44406 }
44407
44408
44409 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44410 PyObject *resultobj = 0;
44411 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44412 wxMenu *arg2 = (wxMenu *) 0 ;
44413 wxString *arg3 = 0 ;
44414 bool result;
44415 void *argp1 = 0 ;
44416 int res1 = 0 ;
44417 void *argp2 = 0 ;
44418 int res2 = 0 ;
44419 bool temp3 = false ;
44420 PyObject * obj0 = 0 ;
44421 PyObject * obj1 = 0 ;
44422 PyObject * obj2 = 0 ;
44423 char * kwnames[] = {
44424 (char *) "self",(char *) "menu",(char *) "title", NULL
44425 };
44426
44427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44429 if (!SWIG_IsOK(res1)) {
44430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44431 }
44432 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44434 if (!SWIG_IsOK(res2)) {
44435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44436 }
44437 arg2 = reinterpret_cast< wxMenu * >(argp2);
44438 {
44439 arg3 = wxString_in_helper(obj2);
44440 if (arg3 == NULL) SWIG_fail;
44441 temp3 = true;
44442 }
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44446 wxPyEndAllowThreads(__tstate);
44447 if (PyErr_Occurred()) SWIG_fail;
44448 }
44449 {
44450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44451 }
44452 {
44453 if (temp3)
44454 delete arg3;
44455 }
44456 return resultobj;
44457 fail:
44458 {
44459 if (temp3)
44460 delete arg3;
44461 }
44462 return NULL;
44463 }
44464
44465
44466 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44467 PyObject *resultobj = 0;
44468 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44469 size_t arg2 ;
44470 wxMenu *arg3 = (wxMenu *) 0 ;
44471 wxString *arg4 = 0 ;
44472 bool result;
44473 void *argp1 = 0 ;
44474 int res1 = 0 ;
44475 size_t val2 ;
44476 int ecode2 = 0 ;
44477 void *argp3 = 0 ;
44478 int res3 = 0 ;
44479 bool temp4 = false ;
44480 PyObject * obj0 = 0 ;
44481 PyObject * obj1 = 0 ;
44482 PyObject * obj2 = 0 ;
44483 PyObject * obj3 = 0 ;
44484 char * kwnames[] = {
44485 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44486 };
44487
44488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44490 if (!SWIG_IsOK(res1)) {
44491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44492 }
44493 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44494 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44495 if (!SWIG_IsOK(ecode2)) {
44496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44497 }
44498 arg2 = static_cast< size_t >(val2);
44499 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44500 if (!SWIG_IsOK(res3)) {
44501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44502 }
44503 arg3 = reinterpret_cast< wxMenu * >(argp3);
44504 {
44505 arg4 = wxString_in_helper(obj3);
44506 if (arg4 == NULL) SWIG_fail;
44507 temp4 = true;
44508 }
44509 {
44510 PyThreadState* __tstate = wxPyBeginAllowThreads();
44511 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44512 wxPyEndAllowThreads(__tstate);
44513 if (PyErr_Occurred()) SWIG_fail;
44514 }
44515 {
44516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44517 }
44518 {
44519 if (temp4)
44520 delete arg4;
44521 }
44522 return resultobj;
44523 fail:
44524 {
44525 if (temp4)
44526 delete arg4;
44527 }
44528 return NULL;
44529 }
44530
44531
44532 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44533 PyObject *resultobj = 0;
44534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44535 size_t result;
44536 void *argp1 = 0 ;
44537 int res1 = 0 ;
44538 PyObject *swig_obj[1] ;
44539
44540 if (!args) SWIG_fail;
44541 swig_obj[0] = args;
44542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44543 if (!SWIG_IsOK(res1)) {
44544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44545 }
44546 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44547 {
44548 PyThreadState* __tstate = wxPyBeginAllowThreads();
44549 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44554 return resultobj;
44555 fail:
44556 return NULL;
44557 }
44558
44559
44560 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44561 PyObject *resultobj = 0;
44562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44563 size_t arg2 ;
44564 wxMenu *result = 0 ;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 size_t val2 ;
44568 int ecode2 = 0 ;
44569 PyObject * obj0 = 0 ;
44570 PyObject * obj1 = 0 ;
44571 char * kwnames[] = {
44572 (char *) "self",(char *) "pos", NULL
44573 };
44574
44575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44579 }
44580 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44581 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44582 if (!SWIG_IsOK(ecode2)) {
44583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44584 }
44585 arg2 = static_cast< size_t >(val2);
44586 {
44587 PyThreadState* __tstate = wxPyBeginAllowThreads();
44588 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 {
44593 resultobj = wxPyMake_wxObject(result, 0);
44594 }
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44602 PyObject *resultobj = 0;
44603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44604 size_t arg2 ;
44605 wxMenu *arg3 = (wxMenu *) 0 ;
44606 wxString *arg4 = 0 ;
44607 wxMenu *result = 0 ;
44608 void *argp1 = 0 ;
44609 int res1 = 0 ;
44610 size_t val2 ;
44611 int ecode2 = 0 ;
44612 void *argp3 = 0 ;
44613 int res3 = 0 ;
44614 bool temp4 = false ;
44615 PyObject * obj0 = 0 ;
44616 PyObject * obj1 = 0 ;
44617 PyObject * obj2 = 0 ;
44618 PyObject * obj3 = 0 ;
44619 char * kwnames[] = {
44620 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44621 };
44622
44623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44625 if (!SWIG_IsOK(res1)) {
44626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44627 }
44628 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44629 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44630 if (!SWIG_IsOK(ecode2)) {
44631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44632 }
44633 arg2 = static_cast< size_t >(val2);
44634 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44635 if (!SWIG_IsOK(res3)) {
44636 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44637 }
44638 arg3 = reinterpret_cast< wxMenu * >(argp3);
44639 {
44640 arg4 = wxString_in_helper(obj3);
44641 if (arg4 == NULL) SWIG_fail;
44642 temp4 = true;
44643 }
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44647 wxPyEndAllowThreads(__tstate);
44648 if (PyErr_Occurred()) SWIG_fail;
44649 }
44650 {
44651 resultobj = wxPyMake_wxObject(result, 0);
44652 }
44653 {
44654 if (temp4)
44655 delete arg4;
44656 }
44657 return resultobj;
44658 fail:
44659 {
44660 if (temp4)
44661 delete arg4;
44662 }
44663 return NULL;
44664 }
44665
44666
44667 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44668 PyObject *resultobj = 0;
44669 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44670 size_t arg2 ;
44671 wxMenu *result = 0 ;
44672 void *argp1 = 0 ;
44673 int res1 = 0 ;
44674 size_t val2 ;
44675 int ecode2 = 0 ;
44676 PyObject * obj0 = 0 ;
44677 PyObject * obj1 = 0 ;
44678 char * kwnames[] = {
44679 (char *) "self",(char *) "pos", NULL
44680 };
44681
44682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44684 if (!SWIG_IsOK(res1)) {
44685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44686 }
44687 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44688 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44689 if (!SWIG_IsOK(ecode2)) {
44690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44691 }
44692 arg2 = static_cast< size_t >(val2);
44693 {
44694 PyThreadState* __tstate = wxPyBeginAllowThreads();
44695 result = (wxMenu *)(arg1)->Remove(arg2);
44696 wxPyEndAllowThreads(__tstate);
44697 if (PyErr_Occurred()) SWIG_fail;
44698 }
44699 {
44700 resultobj = wxPyMake_wxObject(result, 0);
44701 }
44702 return resultobj;
44703 fail:
44704 return NULL;
44705 }
44706
44707
44708 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44709 PyObject *resultobj = 0;
44710 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44711 size_t arg2 ;
44712 bool arg3 ;
44713 void *argp1 = 0 ;
44714 int res1 = 0 ;
44715 size_t val2 ;
44716 int ecode2 = 0 ;
44717 bool val3 ;
44718 int ecode3 = 0 ;
44719 PyObject * obj0 = 0 ;
44720 PyObject * obj1 = 0 ;
44721 PyObject * obj2 = 0 ;
44722 char * kwnames[] = {
44723 (char *) "self",(char *) "pos",(char *) "enable", NULL
44724 };
44725
44726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44728 if (!SWIG_IsOK(res1)) {
44729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44730 }
44731 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44732 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44733 if (!SWIG_IsOK(ecode2)) {
44734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44735 }
44736 arg2 = static_cast< size_t >(val2);
44737 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44738 if (!SWIG_IsOK(ecode3)) {
44739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44740 }
44741 arg3 = static_cast< bool >(val3);
44742 {
44743 PyThreadState* __tstate = wxPyBeginAllowThreads();
44744 (arg1)->EnableTop(arg2,arg3);
44745 wxPyEndAllowThreads(__tstate);
44746 if (PyErr_Occurred()) SWIG_fail;
44747 }
44748 resultobj = SWIG_Py_Void();
44749 return resultobj;
44750 fail:
44751 return NULL;
44752 }
44753
44754
44755 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44756 PyObject *resultobj = 0;
44757 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44758 size_t arg2 ;
44759 bool result;
44760 void *argp1 = 0 ;
44761 int res1 = 0 ;
44762 size_t val2 ;
44763 int ecode2 = 0 ;
44764 PyObject * obj0 = 0 ;
44765 PyObject * obj1 = 0 ;
44766 char * kwnames[] = {
44767 (char *) "self",(char *) "pos", NULL
44768 };
44769
44770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44772 if (!SWIG_IsOK(res1)) {
44773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44774 }
44775 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44776 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44777 if (!SWIG_IsOK(ecode2)) {
44778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44779 }
44780 arg2 = static_cast< size_t >(val2);
44781 {
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 {
44788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44789 }
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj = 0;
44798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44799 size_t arg2 ;
44800 wxString *arg3 = 0 ;
44801 void *argp1 = 0 ;
44802 int res1 = 0 ;
44803 size_t val2 ;
44804 int ecode2 = 0 ;
44805 bool temp3 = false ;
44806 PyObject * obj0 = 0 ;
44807 PyObject * obj1 = 0 ;
44808 PyObject * obj2 = 0 ;
44809 char * kwnames[] = {
44810 (char *) "self",(char *) "pos",(char *) "label", NULL
44811 };
44812
44813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44815 if (!SWIG_IsOK(res1)) {
44816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44817 }
44818 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44819 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44820 if (!SWIG_IsOK(ecode2)) {
44821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44822 }
44823 arg2 = static_cast< size_t >(val2);
44824 {
44825 arg3 = wxString_in_helper(obj2);
44826 if (arg3 == NULL) SWIG_fail;
44827 temp3 = true;
44828 }
44829 {
44830 PyThreadState* __tstate = wxPyBeginAllowThreads();
44831 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44832 wxPyEndAllowThreads(__tstate);
44833 if (PyErr_Occurred()) SWIG_fail;
44834 }
44835 resultobj = SWIG_Py_Void();
44836 {
44837 if (temp3)
44838 delete arg3;
44839 }
44840 return resultobj;
44841 fail:
44842 {
44843 if (temp3)
44844 delete arg3;
44845 }
44846 return NULL;
44847 }
44848
44849
44850 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44851 PyObject *resultobj = 0;
44852 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44853 size_t arg2 ;
44854 wxString result;
44855 void *argp1 = 0 ;
44856 int res1 = 0 ;
44857 size_t val2 ;
44858 int ecode2 = 0 ;
44859 PyObject * obj0 = 0 ;
44860 PyObject * obj1 = 0 ;
44861 char * kwnames[] = {
44862 (char *) "self",(char *) "pos", NULL
44863 };
44864
44865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44867 if (!SWIG_IsOK(res1)) {
44868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44869 }
44870 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44872 if (!SWIG_IsOK(ecode2)) {
44873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44874 }
44875 arg2 = static_cast< size_t >(val2);
44876 {
44877 PyThreadState* __tstate = wxPyBeginAllowThreads();
44878 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44879 wxPyEndAllowThreads(__tstate);
44880 if (PyErr_Occurred()) SWIG_fail;
44881 }
44882 {
44883 #if wxUSE_UNICODE
44884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44885 #else
44886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44887 #endif
44888 }
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj = 0;
44897 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44898 wxString *arg2 = 0 ;
44899 wxString *arg3 = 0 ;
44900 int result;
44901 void *argp1 = 0 ;
44902 int res1 = 0 ;
44903 bool temp2 = false ;
44904 bool temp3 = false ;
44905 PyObject * obj0 = 0 ;
44906 PyObject * obj1 = 0 ;
44907 PyObject * obj2 = 0 ;
44908 char * kwnames[] = {
44909 (char *) "self",(char *) "menu",(char *) "item", NULL
44910 };
44911
44912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44914 if (!SWIG_IsOK(res1)) {
44915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44916 }
44917 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44918 {
44919 arg2 = wxString_in_helper(obj1);
44920 if (arg2 == NULL) SWIG_fail;
44921 temp2 = true;
44922 }
44923 {
44924 arg3 = wxString_in_helper(obj2);
44925 if (arg3 == NULL) SWIG_fail;
44926 temp3 = true;
44927 }
44928 {
44929 PyThreadState* __tstate = wxPyBeginAllowThreads();
44930 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 resultobj = SWIG_From_int(static_cast< int >(result));
44935 {
44936 if (temp2)
44937 delete arg2;
44938 }
44939 {
44940 if (temp3)
44941 delete arg3;
44942 }
44943 return resultobj;
44944 fail:
44945 {
44946 if (temp2)
44947 delete arg2;
44948 }
44949 {
44950 if (temp3)
44951 delete arg3;
44952 }
44953 return NULL;
44954 }
44955
44956
44957 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44958 PyObject *resultobj = 0;
44959 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44960 int arg2 ;
44961 wxMenuItem *result = 0 ;
44962 void *argp1 = 0 ;
44963 int res1 = 0 ;
44964 int val2 ;
44965 int ecode2 = 0 ;
44966 PyObject * obj0 = 0 ;
44967 PyObject * obj1 = 0 ;
44968 char * kwnames[] = {
44969 (char *) "self",(char *) "id", NULL
44970 };
44971
44972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44976 }
44977 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44978 ecode2 = SWIG_AsVal_int(obj1, &val2);
44979 if (!SWIG_IsOK(ecode2)) {
44980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44981 }
44982 arg2 = static_cast< int >(val2);
44983 {
44984 PyThreadState* __tstate = wxPyBeginAllowThreads();
44985 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44986 wxPyEndAllowThreads(__tstate);
44987 if (PyErr_Occurred()) SWIG_fail;
44988 }
44989 {
44990 resultobj = wxPyMake_wxObject(result, (bool)0);
44991 }
44992 return resultobj;
44993 fail:
44994 return NULL;
44995 }
44996
44997
44998 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44999 PyObject *resultobj = 0;
45000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45001 wxString *arg2 = 0 ;
45002 int result;
45003 void *argp1 = 0 ;
45004 int res1 = 0 ;
45005 bool temp2 = false ;
45006 PyObject * obj0 = 0 ;
45007 PyObject * obj1 = 0 ;
45008 char * kwnames[] = {
45009 (char *) "self",(char *) "title", NULL
45010 };
45011
45012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45014 if (!SWIG_IsOK(res1)) {
45015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45016 }
45017 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45018 {
45019 arg2 = wxString_in_helper(obj1);
45020 if (arg2 == NULL) SWIG_fail;
45021 temp2 = true;
45022 }
45023 {
45024 PyThreadState* __tstate = wxPyBeginAllowThreads();
45025 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45026 wxPyEndAllowThreads(__tstate);
45027 if (PyErr_Occurred()) SWIG_fail;
45028 }
45029 resultobj = SWIG_From_int(static_cast< int >(result));
45030 {
45031 if (temp2)
45032 delete arg2;
45033 }
45034 return resultobj;
45035 fail:
45036 {
45037 if (temp2)
45038 delete arg2;
45039 }
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45045 PyObject *resultobj = 0;
45046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45047 int arg2 ;
45048 bool arg3 ;
45049 void *argp1 = 0 ;
45050 int res1 = 0 ;
45051 int val2 ;
45052 int ecode2 = 0 ;
45053 bool val3 ;
45054 int ecode3 = 0 ;
45055 PyObject * obj0 = 0 ;
45056 PyObject * obj1 = 0 ;
45057 PyObject * obj2 = 0 ;
45058 char * kwnames[] = {
45059 (char *) "self",(char *) "id",(char *) "enable", NULL
45060 };
45061
45062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45064 if (!SWIG_IsOK(res1)) {
45065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45066 }
45067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45068 ecode2 = SWIG_AsVal_int(obj1, &val2);
45069 if (!SWIG_IsOK(ecode2)) {
45070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45071 }
45072 arg2 = static_cast< int >(val2);
45073 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45074 if (!SWIG_IsOK(ecode3)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45076 }
45077 arg3 = static_cast< bool >(val3);
45078 {
45079 PyThreadState* __tstate = wxPyBeginAllowThreads();
45080 (arg1)->Enable(arg2,arg3);
45081 wxPyEndAllowThreads(__tstate);
45082 if (PyErr_Occurred()) SWIG_fail;
45083 }
45084 resultobj = SWIG_Py_Void();
45085 return resultobj;
45086 fail:
45087 return NULL;
45088 }
45089
45090
45091 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45092 PyObject *resultobj = 0;
45093 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45094 int arg2 ;
45095 bool arg3 ;
45096 void *argp1 = 0 ;
45097 int res1 = 0 ;
45098 int val2 ;
45099 int ecode2 = 0 ;
45100 bool val3 ;
45101 int ecode3 = 0 ;
45102 PyObject * obj0 = 0 ;
45103 PyObject * obj1 = 0 ;
45104 PyObject * obj2 = 0 ;
45105 char * kwnames[] = {
45106 (char *) "self",(char *) "id",(char *) "check", NULL
45107 };
45108
45109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45111 if (!SWIG_IsOK(res1)) {
45112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45113 }
45114 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45115 ecode2 = SWIG_AsVal_int(obj1, &val2);
45116 if (!SWIG_IsOK(ecode2)) {
45117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45118 }
45119 arg2 = static_cast< int >(val2);
45120 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45121 if (!SWIG_IsOK(ecode3)) {
45122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45123 }
45124 arg3 = static_cast< bool >(val3);
45125 {
45126 PyThreadState* __tstate = wxPyBeginAllowThreads();
45127 (arg1)->Check(arg2,arg3);
45128 wxPyEndAllowThreads(__tstate);
45129 if (PyErr_Occurred()) SWIG_fail;
45130 }
45131 resultobj = SWIG_Py_Void();
45132 return resultobj;
45133 fail:
45134 return NULL;
45135 }
45136
45137
45138 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45139 PyObject *resultobj = 0;
45140 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45141 int arg2 ;
45142 bool result;
45143 void *argp1 = 0 ;
45144 int res1 = 0 ;
45145 int val2 ;
45146 int ecode2 = 0 ;
45147 PyObject * obj0 = 0 ;
45148 PyObject * obj1 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "self",(char *) "id", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45157 }
45158 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45159 ecode2 = SWIG_AsVal_int(obj1, &val2);
45160 if (!SWIG_IsOK(ecode2)) {
45161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45162 }
45163 arg2 = static_cast< int >(val2);
45164 {
45165 PyThreadState* __tstate = wxPyBeginAllowThreads();
45166 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 {
45171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45172 }
45173 return resultobj;
45174 fail:
45175 return NULL;
45176 }
45177
45178
45179 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45180 PyObject *resultobj = 0;
45181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45182 int arg2 ;
45183 bool result;
45184 void *argp1 = 0 ;
45185 int res1 = 0 ;
45186 int val2 ;
45187 int ecode2 = 0 ;
45188 PyObject * obj0 = 0 ;
45189 PyObject * obj1 = 0 ;
45190 char * kwnames[] = {
45191 (char *) "self",(char *) "id", NULL
45192 };
45193
45194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45196 if (!SWIG_IsOK(res1)) {
45197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45198 }
45199 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45200 ecode2 = SWIG_AsVal_int(obj1, &val2);
45201 if (!SWIG_IsOK(ecode2)) {
45202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45203 }
45204 arg2 = static_cast< int >(val2);
45205 {
45206 PyThreadState* __tstate = wxPyBeginAllowThreads();
45207 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45208 wxPyEndAllowThreads(__tstate);
45209 if (PyErr_Occurred()) SWIG_fail;
45210 }
45211 {
45212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45213 }
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj = 0;
45222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45223 int arg2 ;
45224 wxString *arg3 = 0 ;
45225 void *argp1 = 0 ;
45226 int res1 = 0 ;
45227 int val2 ;
45228 int ecode2 = 0 ;
45229 bool temp3 = false ;
45230 PyObject * obj0 = 0 ;
45231 PyObject * obj1 = 0 ;
45232 PyObject * obj2 = 0 ;
45233 char * kwnames[] = {
45234 (char *) "self",(char *) "id",(char *) "label", NULL
45235 };
45236
45237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45239 if (!SWIG_IsOK(res1)) {
45240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45241 }
45242 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45243 ecode2 = SWIG_AsVal_int(obj1, &val2);
45244 if (!SWIG_IsOK(ecode2)) {
45245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45246 }
45247 arg2 = static_cast< int >(val2);
45248 {
45249 arg3 = wxString_in_helper(obj2);
45250 if (arg3 == NULL) SWIG_fail;
45251 temp3 = true;
45252 }
45253 {
45254 PyThreadState* __tstate = wxPyBeginAllowThreads();
45255 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45256 wxPyEndAllowThreads(__tstate);
45257 if (PyErr_Occurred()) SWIG_fail;
45258 }
45259 resultobj = SWIG_Py_Void();
45260 {
45261 if (temp3)
45262 delete arg3;
45263 }
45264 return resultobj;
45265 fail:
45266 {
45267 if (temp3)
45268 delete arg3;
45269 }
45270 return NULL;
45271 }
45272
45273
45274 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45275 PyObject *resultobj = 0;
45276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45277 int arg2 ;
45278 wxString result;
45279 void *argp1 = 0 ;
45280 int res1 = 0 ;
45281 int val2 ;
45282 int ecode2 = 0 ;
45283 PyObject * obj0 = 0 ;
45284 PyObject * obj1 = 0 ;
45285 char * kwnames[] = {
45286 (char *) "self",(char *) "id", NULL
45287 };
45288
45289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45291 if (!SWIG_IsOK(res1)) {
45292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45293 }
45294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45295 ecode2 = SWIG_AsVal_int(obj1, &val2);
45296 if (!SWIG_IsOK(ecode2)) {
45297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45298 }
45299 arg2 = static_cast< int >(val2);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 {
45307 #if wxUSE_UNICODE
45308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45309 #else
45310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45311 #endif
45312 }
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45320 PyObject *resultobj = 0;
45321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45322 int arg2 ;
45323 wxString *arg3 = 0 ;
45324 void *argp1 = 0 ;
45325 int res1 = 0 ;
45326 int val2 ;
45327 int ecode2 = 0 ;
45328 bool temp3 = false ;
45329 PyObject * obj0 = 0 ;
45330 PyObject * obj1 = 0 ;
45331 PyObject * obj2 = 0 ;
45332 char * kwnames[] = {
45333 (char *) "self",(char *) "id",(char *) "helpString", NULL
45334 };
45335
45336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45338 if (!SWIG_IsOK(res1)) {
45339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45340 }
45341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45342 ecode2 = SWIG_AsVal_int(obj1, &val2);
45343 if (!SWIG_IsOK(ecode2)) {
45344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45345 }
45346 arg2 = static_cast< int >(val2);
45347 {
45348 arg3 = wxString_in_helper(obj2);
45349 if (arg3 == NULL) SWIG_fail;
45350 temp3 = true;
45351 }
45352 {
45353 PyThreadState* __tstate = wxPyBeginAllowThreads();
45354 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45355 wxPyEndAllowThreads(__tstate);
45356 if (PyErr_Occurred()) SWIG_fail;
45357 }
45358 resultobj = SWIG_Py_Void();
45359 {
45360 if (temp3)
45361 delete arg3;
45362 }
45363 return resultobj;
45364 fail:
45365 {
45366 if (temp3)
45367 delete arg3;
45368 }
45369 return NULL;
45370 }
45371
45372
45373 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45374 PyObject *resultobj = 0;
45375 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45376 int arg2 ;
45377 wxString result;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 int val2 ;
45381 int ecode2 = 0 ;
45382 PyObject * obj0 = 0 ;
45383 PyObject * obj1 = 0 ;
45384 char * kwnames[] = {
45385 (char *) "self",(char *) "id", NULL
45386 };
45387
45388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45390 if (!SWIG_IsOK(res1)) {
45391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45392 }
45393 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45394 ecode2 = SWIG_AsVal_int(obj1, &val2);
45395 if (!SWIG_IsOK(ecode2)) {
45396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45397 }
45398 arg2 = static_cast< int >(val2);
45399 {
45400 PyThreadState* __tstate = wxPyBeginAllowThreads();
45401 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45402 wxPyEndAllowThreads(__tstate);
45403 if (PyErr_Occurred()) SWIG_fail;
45404 }
45405 {
45406 #if wxUSE_UNICODE
45407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45408 #else
45409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45410 #endif
45411 }
45412 return resultobj;
45413 fail:
45414 return NULL;
45415 }
45416
45417
45418 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45419 PyObject *resultobj = 0;
45420 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45421 wxFrame *result = 0 ;
45422 void *argp1 = 0 ;
45423 int res1 = 0 ;
45424 PyObject *swig_obj[1] ;
45425
45426 if (!args) SWIG_fail;
45427 swig_obj[0] = args;
45428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45429 if (!SWIG_IsOK(res1)) {
45430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45431 }
45432 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45433 {
45434 PyThreadState* __tstate = wxPyBeginAllowThreads();
45435 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45436 wxPyEndAllowThreads(__tstate);
45437 if (PyErr_Occurred()) SWIG_fail;
45438 }
45439 {
45440 resultobj = wxPyMake_wxObject(result, (bool)0);
45441 }
45442 return resultobj;
45443 fail:
45444 return NULL;
45445 }
45446
45447
45448 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45449 PyObject *resultobj = 0;
45450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45451 bool result;
45452 void *argp1 = 0 ;
45453 int res1 = 0 ;
45454 PyObject *swig_obj[1] ;
45455
45456 if (!args) SWIG_fail;
45457 swig_obj[0] = args;
45458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45459 if (!SWIG_IsOK(res1)) {
45460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45461 }
45462 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 {
45470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45471 }
45472 return resultobj;
45473 fail:
45474 return NULL;
45475 }
45476
45477
45478 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45479 PyObject *resultobj = 0;
45480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45481 wxFrame *arg2 = (wxFrame *) 0 ;
45482 void *argp1 = 0 ;
45483 int res1 = 0 ;
45484 void *argp2 = 0 ;
45485 int res2 = 0 ;
45486 PyObject * obj0 = 0 ;
45487 PyObject * obj1 = 0 ;
45488 char * kwnames[] = {
45489 (char *) "self",(char *) "frame", NULL
45490 };
45491
45492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45494 if (!SWIG_IsOK(res1)) {
45495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45496 }
45497 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45499 if (!SWIG_IsOK(res2)) {
45500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45501 }
45502 arg2 = reinterpret_cast< wxFrame * >(argp2);
45503 {
45504 PyThreadState* __tstate = wxPyBeginAllowThreads();
45505 (arg1)->Attach(arg2);
45506 wxPyEndAllowThreads(__tstate);
45507 if (PyErr_Occurred()) SWIG_fail;
45508 }
45509 resultobj = SWIG_Py_Void();
45510 return resultobj;
45511 fail:
45512 return NULL;
45513 }
45514
45515
45516 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45517 PyObject *resultobj = 0;
45518 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45519 void *argp1 = 0 ;
45520 int res1 = 0 ;
45521 PyObject *swig_obj[1] ;
45522
45523 if (!args) SWIG_fail;
45524 swig_obj[0] = args;
45525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45526 if (!SWIG_IsOK(res1)) {
45527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45528 }
45529 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45530 {
45531 PyThreadState* __tstate = wxPyBeginAllowThreads();
45532 (arg1)->Detach();
45533 wxPyEndAllowThreads(__tstate);
45534 if (PyErr_Occurred()) SWIG_fail;
45535 }
45536 resultobj = SWIG_Py_Void();
45537 return resultobj;
45538 fail:
45539 return NULL;
45540 }
45541
45542
45543 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45544 PyObject *resultobj = 0;
45545 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45546 void *argp1 = 0 ;
45547 int res1 = 0 ;
45548 PyObject *swig_obj[1] ;
45549
45550 if (!args) SWIG_fail;
45551 swig_obj[0] = args;
45552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45553 if (!SWIG_IsOK(res1)) {
45554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45555 }
45556 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45557 {
45558 PyThreadState* __tstate = wxPyBeginAllowThreads();
45559 (arg1)->UpdateMenus();
45560 wxPyEndAllowThreads(__tstate);
45561 if (PyErr_Occurred()) SWIG_fail;
45562 }
45563 resultobj = SWIG_Py_Void();
45564 return resultobj;
45565 fail:
45566 return NULL;
45567 }
45568
45569
45570 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45571 PyObject *resultobj = 0;
45572 bool arg1 ;
45573 bool val1 ;
45574 int ecode1 = 0 ;
45575 PyObject * obj0 = 0 ;
45576 char * kwnames[] = {
45577 (char *) "enable", NULL
45578 };
45579
45580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45581 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45582 if (!SWIG_IsOK(ecode1)) {
45583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45584 }
45585 arg1 = static_cast< bool >(val1);
45586 {
45587 PyThreadState* __tstate = wxPyBeginAllowThreads();
45588 wxMenuBar::SetAutoWindowMenu(arg1);
45589 wxPyEndAllowThreads(__tstate);
45590 if (PyErr_Occurred()) SWIG_fail;
45591 }
45592 resultobj = SWIG_Py_Void();
45593 return resultobj;
45594 fail:
45595 return NULL;
45596 }
45597
45598
45599 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45600 PyObject *resultobj = 0;
45601 bool result;
45602
45603 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45604 {
45605 PyThreadState* __tstate = wxPyBeginAllowThreads();
45606 result = (bool)wxMenuBar::GetAutoWindowMenu();
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 {
45611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45612 }
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45620 PyObject *obj;
45621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45622 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45623 return SWIG_Py_Void();
45624 }
45625
45626 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45627 return SWIG_Python_InitShadowInstance(args);
45628 }
45629
45630 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45631 PyObject *resultobj = 0;
45632 wxMenu *arg1 = (wxMenu *) NULL ;
45633 int arg2 = (int) wxID_ANY ;
45634 wxString const &arg3_defvalue = wxPyEmptyString ;
45635 wxString *arg3 = (wxString *) &arg3_defvalue ;
45636 wxString const &arg4_defvalue = wxPyEmptyString ;
45637 wxString *arg4 = (wxString *) &arg4_defvalue ;
45638 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45639 wxMenu *arg6 = (wxMenu *) NULL ;
45640 wxMenuItem *result = 0 ;
45641 void *argp1 = 0 ;
45642 int res1 = 0 ;
45643 int val2 ;
45644 int ecode2 = 0 ;
45645 bool temp3 = false ;
45646 bool temp4 = false ;
45647 int val5 ;
45648 int ecode5 = 0 ;
45649 void *argp6 = 0 ;
45650 int res6 = 0 ;
45651 PyObject * obj0 = 0 ;
45652 PyObject * obj1 = 0 ;
45653 PyObject * obj2 = 0 ;
45654 PyObject * obj3 = 0 ;
45655 PyObject * obj4 = 0 ;
45656 PyObject * obj5 = 0 ;
45657 char * kwnames[] = {
45658 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45659 };
45660
45661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45662 if (obj0) {
45663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45664 if (!SWIG_IsOK(res1)) {
45665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45666 }
45667 arg1 = reinterpret_cast< wxMenu * >(argp1);
45668 }
45669 if (obj1) {
45670 ecode2 = SWIG_AsVal_int(obj1, &val2);
45671 if (!SWIG_IsOK(ecode2)) {
45672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45673 }
45674 arg2 = static_cast< int >(val2);
45675 }
45676 if (obj2) {
45677 {
45678 arg3 = wxString_in_helper(obj2);
45679 if (arg3 == NULL) SWIG_fail;
45680 temp3 = true;
45681 }
45682 }
45683 if (obj3) {
45684 {
45685 arg4 = wxString_in_helper(obj3);
45686 if (arg4 == NULL) SWIG_fail;
45687 temp4 = true;
45688 }
45689 }
45690 if (obj4) {
45691 ecode5 = SWIG_AsVal_int(obj4, &val5);
45692 if (!SWIG_IsOK(ecode5)) {
45693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45694 }
45695 arg5 = static_cast< wxItemKind >(val5);
45696 }
45697 if (obj5) {
45698 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45699 if (!SWIG_IsOK(res6)) {
45700 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45701 }
45702 arg6 = reinterpret_cast< wxMenu * >(argp6);
45703 }
45704 {
45705 PyThreadState* __tstate = wxPyBeginAllowThreads();
45706 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45707 wxPyEndAllowThreads(__tstate);
45708 if (PyErr_Occurred()) SWIG_fail;
45709 }
45710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45711 {
45712 if (temp3)
45713 delete arg3;
45714 }
45715 {
45716 if (temp4)
45717 delete arg4;
45718 }
45719 return resultobj;
45720 fail:
45721 {
45722 if (temp3)
45723 delete arg3;
45724 }
45725 {
45726 if (temp4)
45727 delete arg4;
45728 }
45729 return NULL;
45730 }
45731
45732
45733 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45734 PyObject *resultobj = 0;
45735 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45736 void *argp1 = 0 ;
45737 int res1 = 0 ;
45738 PyObject *swig_obj[1] ;
45739
45740 if (!args) SWIG_fail;
45741 swig_obj[0] = args;
45742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45743 if (!SWIG_IsOK(res1)) {
45744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45745 }
45746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45747 {
45748 PyThreadState* __tstate = wxPyBeginAllowThreads();
45749 delete arg1;
45750
45751 wxPyEndAllowThreads(__tstate);
45752 if (PyErr_Occurred()) SWIG_fail;
45753 }
45754 resultobj = SWIG_Py_Void();
45755 return resultobj;
45756 fail:
45757 return NULL;
45758 }
45759
45760
45761 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45762 PyObject *resultobj = 0;
45763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45764 wxMenu *result = 0 ;
45765 void *argp1 = 0 ;
45766 int res1 = 0 ;
45767 PyObject *swig_obj[1] ;
45768
45769 if (!args) SWIG_fail;
45770 swig_obj[0] = args;
45771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45772 if (!SWIG_IsOK(res1)) {
45773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45774 }
45775 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45776 {
45777 PyThreadState* __tstate = wxPyBeginAllowThreads();
45778 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45779 wxPyEndAllowThreads(__tstate);
45780 if (PyErr_Occurred()) SWIG_fail;
45781 }
45782 {
45783 resultobj = wxPyMake_wxObject(result, 0);
45784 }
45785 return resultobj;
45786 fail:
45787 return NULL;
45788 }
45789
45790
45791 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45792 PyObject *resultobj = 0;
45793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45794 wxMenu *arg2 = (wxMenu *) 0 ;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 void *argp2 = 0 ;
45798 int res2 = 0 ;
45799 PyObject * obj0 = 0 ;
45800 PyObject * obj1 = 0 ;
45801 char * kwnames[] = {
45802 (char *) "self",(char *) "menu", NULL
45803 };
45804
45805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45807 if (!SWIG_IsOK(res1)) {
45808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45809 }
45810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45812 if (!SWIG_IsOK(res2)) {
45813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45814 }
45815 arg2 = reinterpret_cast< wxMenu * >(argp2);
45816 {
45817 PyThreadState* __tstate = wxPyBeginAllowThreads();
45818 (arg1)->SetMenu(arg2);
45819 wxPyEndAllowThreads(__tstate);
45820 if (PyErr_Occurred()) SWIG_fail;
45821 }
45822 resultobj = SWIG_Py_Void();
45823 return resultobj;
45824 fail:
45825 return NULL;
45826 }
45827
45828
45829 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45830 PyObject *resultobj = 0;
45831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45832 int arg2 ;
45833 void *argp1 = 0 ;
45834 int res1 = 0 ;
45835 int val2 ;
45836 int ecode2 = 0 ;
45837 PyObject * obj0 = 0 ;
45838 PyObject * obj1 = 0 ;
45839 char * kwnames[] = {
45840 (char *) "self",(char *) "id", NULL
45841 };
45842
45843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45845 if (!SWIG_IsOK(res1)) {
45846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45847 }
45848 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45849 ecode2 = SWIG_AsVal_int(obj1, &val2);
45850 if (!SWIG_IsOK(ecode2)) {
45851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45852 }
45853 arg2 = static_cast< int >(val2);
45854 {
45855 PyThreadState* __tstate = wxPyBeginAllowThreads();
45856 (arg1)->SetId(arg2);
45857 wxPyEndAllowThreads(__tstate);
45858 if (PyErr_Occurred()) SWIG_fail;
45859 }
45860 resultobj = SWIG_Py_Void();
45861 return resultobj;
45862 fail:
45863 return NULL;
45864 }
45865
45866
45867 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45868 PyObject *resultobj = 0;
45869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45870 int result;
45871 void *argp1 = 0 ;
45872 int res1 = 0 ;
45873 PyObject *swig_obj[1] ;
45874
45875 if (!args) SWIG_fail;
45876 swig_obj[0] = args;
45877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45878 if (!SWIG_IsOK(res1)) {
45879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45880 }
45881 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 result = (int)((wxMenuItem const *)arg1)->GetId();
45885 wxPyEndAllowThreads(__tstate);
45886 if (PyErr_Occurred()) SWIG_fail;
45887 }
45888 resultobj = SWIG_From_int(static_cast< int >(result));
45889 return resultobj;
45890 fail:
45891 return NULL;
45892 }
45893
45894
45895 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45896 PyObject *resultobj = 0;
45897 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45898 bool result;
45899 void *argp1 = 0 ;
45900 int res1 = 0 ;
45901 PyObject *swig_obj[1] ;
45902
45903 if (!args) SWIG_fail;
45904 swig_obj[0] = args;
45905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45906 if (!SWIG_IsOK(res1)) {
45907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45908 }
45909 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 {
45917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45918 }
45919 return resultobj;
45920 fail:
45921 return NULL;
45922 }
45923
45924
45925 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45926 PyObject *resultobj = 0;
45927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45928 wxString *arg2 = 0 ;
45929 void *argp1 = 0 ;
45930 int res1 = 0 ;
45931 bool temp2 = false ;
45932 PyObject * obj0 = 0 ;
45933 PyObject * obj1 = 0 ;
45934 char * kwnames[] = {
45935 (char *) "self",(char *) "str", NULL
45936 };
45937
45938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45942 }
45943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45944 {
45945 arg2 = wxString_in_helper(obj1);
45946 if (arg2 == NULL) SWIG_fail;
45947 temp2 = true;
45948 }
45949 {
45950 PyThreadState* __tstate = wxPyBeginAllowThreads();
45951 (arg1)->SetText((wxString const &)*arg2);
45952 wxPyEndAllowThreads(__tstate);
45953 if (PyErr_Occurred()) SWIG_fail;
45954 }
45955 resultobj = SWIG_Py_Void();
45956 {
45957 if (temp2)
45958 delete arg2;
45959 }
45960 return resultobj;
45961 fail:
45962 {
45963 if (temp2)
45964 delete arg2;
45965 }
45966 return NULL;
45967 }
45968
45969
45970 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45971 PyObject *resultobj = 0;
45972 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45973 wxString result;
45974 void *argp1 = 0 ;
45975 int res1 = 0 ;
45976 PyObject *swig_obj[1] ;
45977
45978 if (!args) SWIG_fail;
45979 swig_obj[0] = args;
45980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45981 if (!SWIG_IsOK(res1)) {
45982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45983 }
45984 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45985 {
45986 PyThreadState* __tstate = wxPyBeginAllowThreads();
45987 result = ((wxMenuItem const *)arg1)->GetLabel();
45988 wxPyEndAllowThreads(__tstate);
45989 if (PyErr_Occurred()) SWIG_fail;
45990 }
45991 {
45992 #if wxUSE_UNICODE
45993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45994 #else
45995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45996 #endif
45997 }
45998 return resultobj;
45999 fail:
46000 return NULL;
46001 }
46002
46003
46004 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46005 PyObject *resultobj = 0;
46006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46007 wxString *result = 0 ;
46008 void *argp1 = 0 ;
46009 int res1 = 0 ;
46010 PyObject *swig_obj[1] ;
46011
46012 if (!args) SWIG_fail;
46013 swig_obj[0] = args;
46014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46015 if (!SWIG_IsOK(res1)) {
46016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46017 }
46018 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46019 {
46020 PyThreadState* __tstate = wxPyBeginAllowThreads();
46021 {
46022 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46023 result = (wxString *) &_result_ref;
46024 }
46025 wxPyEndAllowThreads(__tstate);
46026 if (PyErr_Occurred()) SWIG_fail;
46027 }
46028 {
46029 #if wxUSE_UNICODE
46030 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46031 #else
46032 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46033 #endif
46034 }
46035 return resultobj;
46036 fail:
46037 return NULL;
46038 }
46039
46040
46041 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46042 PyObject *resultobj = 0;
46043 wxString *arg1 = 0 ;
46044 wxString result;
46045 bool temp1 = false ;
46046 PyObject * obj0 = 0 ;
46047 char * kwnames[] = {
46048 (char *) "text", NULL
46049 };
46050
46051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46052 {
46053 arg1 = wxString_in_helper(obj0);
46054 if (arg1 == NULL) SWIG_fail;
46055 temp1 = true;
46056 }
46057 {
46058 PyThreadState* __tstate = wxPyBeginAllowThreads();
46059 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46060 wxPyEndAllowThreads(__tstate);
46061 if (PyErr_Occurred()) SWIG_fail;
46062 }
46063 {
46064 #if wxUSE_UNICODE
46065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46066 #else
46067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46068 #endif
46069 }
46070 {
46071 if (temp1)
46072 delete arg1;
46073 }
46074 return resultobj;
46075 fail:
46076 {
46077 if (temp1)
46078 delete arg1;
46079 }
46080 return NULL;
46081 }
46082
46083
46084 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46085 PyObject *resultobj = 0;
46086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46087 wxItemKind result;
46088 void *argp1 = 0 ;
46089 int res1 = 0 ;
46090 PyObject *swig_obj[1] ;
46091
46092 if (!args) SWIG_fail;
46093 swig_obj[0] = args;
46094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46095 if (!SWIG_IsOK(res1)) {
46096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46097 }
46098 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46099 {
46100 PyThreadState* __tstate = wxPyBeginAllowThreads();
46101 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46102 wxPyEndAllowThreads(__tstate);
46103 if (PyErr_Occurred()) SWIG_fail;
46104 }
46105 resultobj = SWIG_From_int(static_cast< int >(result));
46106 return resultobj;
46107 fail:
46108 return NULL;
46109 }
46110
46111
46112 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46113 PyObject *resultobj = 0;
46114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46115 wxItemKind arg2 ;
46116 void *argp1 = 0 ;
46117 int res1 = 0 ;
46118 int val2 ;
46119 int ecode2 = 0 ;
46120 PyObject * obj0 = 0 ;
46121 PyObject * obj1 = 0 ;
46122 char * kwnames[] = {
46123 (char *) "self",(char *) "kind", NULL
46124 };
46125
46126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46128 if (!SWIG_IsOK(res1)) {
46129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46130 }
46131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46132 ecode2 = SWIG_AsVal_int(obj1, &val2);
46133 if (!SWIG_IsOK(ecode2)) {
46134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46135 }
46136 arg2 = static_cast< wxItemKind >(val2);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 (arg1)->SetKind(arg2);
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_Py_Void();
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46153 bool arg2 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 bool val2 ;
46157 int ecode2 = 0 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "checkable", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46168 }
46169 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46171 if (!SWIG_IsOK(ecode2)) {
46172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46173 }
46174 arg2 = static_cast< bool >(val2);
46175 {
46176 PyThreadState* __tstate = wxPyBeginAllowThreads();
46177 (arg1)->SetCheckable(arg2);
46178 wxPyEndAllowThreads(__tstate);
46179 if (PyErr_Occurred()) SWIG_fail;
46180 }
46181 resultobj = SWIG_Py_Void();
46182 return resultobj;
46183 fail:
46184 return NULL;
46185 }
46186
46187
46188 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46189 PyObject *resultobj = 0;
46190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46191 bool result;
46192 void *argp1 = 0 ;
46193 int res1 = 0 ;
46194 PyObject *swig_obj[1] ;
46195
46196 if (!args) SWIG_fail;
46197 swig_obj[0] = args;
46198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46199 if (!SWIG_IsOK(res1)) {
46200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46201 }
46202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46203 {
46204 PyThreadState* __tstate = wxPyBeginAllowThreads();
46205 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46206 wxPyEndAllowThreads(__tstate);
46207 if (PyErr_Occurred()) SWIG_fail;
46208 }
46209 {
46210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46211 }
46212 return resultobj;
46213 fail:
46214 return NULL;
46215 }
46216
46217
46218 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46219 PyObject *resultobj = 0;
46220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46221 bool result;
46222 void *argp1 = 0 ;
46223 int res1 = 0 ;
46224 PyObject *swig_obj[1] ;
46225
46226 if (!args) SWIG_fail;
46227 swig_obj[0] = args;
46228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46229 if (!SWIG_IsOK(res1)) {
46230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46231 }
46232 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46233 {
46234 PyThreadState* __tstate = wxPyBeginAllowThreads();
46235 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46236 wxPyEndAllowThreads(__tstate);
46237 if (PyErr_Occurred()) SWIG_fail;
46238 }
46239 {
46240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46241 }
46242 return resultobj;
46243 fail:
46244 return NULL;
46245 }
46246
46247
46248 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46249 PyObject *resultobj = 0;
46250 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46251 wxMenu *arg2 = (wxMenu *) 0 ;
46252 void *argp1 = 0 ;
46253 int res1 = 0 ;
46254 void *argp2 = 0 ;
46255 int res2 = 0 ;
46256 PyObject * obj0 = 0 ;
46257 PyObject * obj1 = 0 ;
46258 char * kwnames[] = {
46259 (char *) "self",(char *) "menu", NULL
46260 };
46261
46262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46264 if (!SWIG_IsOK(res1)) {
46265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46266 }
46267 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46269 if (!SWIG_IsOK(res2)) {
46270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46271 }
46272 arg2 = reinterpret_cast< wxMenu * >(argp2);
46273 {
46274 PyThreadState* __tstate = wxPyBeginAllowThreads();
46275 (arg1)->SetSubMenu(arg2);
46276 wxPyEndAllowThreads(__tstate);
46277 if (PyErr_Occurred()) SWIG_fail;
46278 }
46279 resultobj = SWIG_Py_Void();
46280 return resultobj;
46281 fail:
46282 return NULL;
46283 }
46284
46285
46286 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46287 PyObject *resultobj = 0;
46288 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46289 wxMenu *result = 0 ;
46290 void *argp1 = 0 ;
46291 int res1 = 0 ;
46292 PyObject *swig_obj[1] ;
46293
46294 if (!args) SWIG_fail;
46295 swig_obj[0] = args;
46296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46297 if (!SWIG_IsOK(res1)) {
46298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46299 }
46300 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46301 {
46302 PyThreadState* __tstate = wxPyBeginAllowThreads();
46303 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46304 wxPyEndAllowThreads(__tstate);
46305 if (PyErr_Occurred()) SWIG_fail;
46306 }
46307 {
46308 resultobj = wxPyMake_wxObject(result, 0);
46309 }
46310 return resultobj;
46311 fail:
46312 return NULL;
46313 }
46314
46315
46316 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46317 PyObject *resultobj = 0;
46318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46319 bool arg2 = (bool) true ;
46320 void *argp1 = 0 ;
46321 int res1 = 0 ;
46322 bool val2 ;
46323 int ecode2 = 0 ;
46324 PyObject * obj0 = 0 ;
46325 PyObject * obj1 = 0 ;
46326 char * kwnames[] = {
46327 (char *) "self",(char *) "enable", NULL
46328 };
46329
46330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46332 if (!SWIG_IsOK(res1)) {
46333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46334 }
46335 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46336 if (obj1) {
46337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46338 if (!SWIG_IsOK(ecode2)) {
46339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46340 }
46341 arg2 = static_cast< bool >(val2);
46342 }
46343 {
46344 PyThreadState* __tstate = wxPyBeginAllowThreads();
46345 (arg1)->Enable(arg2);
46346 wxPyEndAllowThreads(__tstate);
46347 if (PyErr_Occurred()) SWIG_fail;
46348 }
46349 resultobj = SWIG_Py_Void();
46350 return resultobj;
46351 fail:
46352 return NULL;
46353 }
46354
46355
46356 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46357 PyObject *resultobj = 0;
46358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46359 bool result;
46360 void *argp1 = 0 ;
46361 int res1 = 0 ;
46362 PyObject *swig_obj[1] ;
46363
46364 if (!args) SWIG_fail;
46365 swig_obj[0] = args;
46366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46367 if (!SWIG_IsOK(res1)) {
46368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46369 }
46370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46371 {
46372 PyThreadState* __tstate = wxPyBeginAllowThreads();
46373 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46374 wxPyEndAllowThreads(__tstate);
46375 if (PyErr_Occurred()) SWIG_fail;
46376 }
46377 {
46378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46379 }
46380 return resultobj;
46381 fail:
46382 return NULL;
46383 }
46384
46385
46386 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46387 PyObject *resultobj = 0;
46388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46389 bool arg2 = (bool) true ;
46390 void *argp1 = 0 ;
46391 int res1 = 0 ;
46392 bool val2 ;
46393 int ecode2 = 0 ;
46394 PyObject * obj0 = 0 ;
46395 PyObject * obj1 = 0 ;
46396 char * kwnames[] = {
46397 (char *) "self",(char *) "check", NULL
46398 };
46399
46400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46402 if (!SWIG_IsOK(res1)) {
46403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46404 }
46405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46406 if (obj1) {
46407 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46408 if (!SWIG_IsOK(ecode2)) {
46409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46410 }
46411 arg2 = static_cast< bool >(val2);
46412 }
46413 {
46414 PyThreadState* __tstate = wxPyBeginAllowThreads();
46415 (arg1)->Check(arg2);
46416 wxPyEndAllowThreads(__tstate);
46417 if (PyErr_Occurred()) SWIG_fail;
46418 }
46419 resultobj = SWIG_Py_Void();
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46427 PyObject *resultobj = 0;
46428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46429 bool result;
46430 void *argp1 = 0 ;
46431 int res1 = 0 ;
46432 PyObject *swig_obj[1] ;
46433
46434 if (!args) SWIG_fail;
46435 swig_obj[0] = args;
46436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46437 if (!SWIG_IsOK(res1)) {
46438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46439 }
46440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46441 {
46442 PyThreadState* __tstate = wxPyBeginAllowThreads();
46443 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46444 wxPyEndAllowThreads(__tstate);
46445 if (PyErr_Occurred()) SWIG_fail;
46446 }
46447 {
46448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46449 }
46450 return resultobj;
46451 fail:
46452 return NULL;
46453 }
46454
46455
46456 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46457 PyObject *resultobj = 0;
46458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46459 void *argp1 = 0 ;
46460 int res1 = 0 ;
46461 PyObject *swig_obj[1] ;
46462
46463 if (!args) SWIG_fail;
46464 swig_obj[0] = args;
46465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46466 if (!SWIG_IsOK(res1)) {
46467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46468 }
46469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46470 {
46471 PyThreadState* __tstate = wxPyBeginAllowThreads();
46472 (arg1)->Toggle();
46473 wxPyEndAllowThreads(__tstate);
46474 if (PyErr_Occurred()) SWIG_fail;
46475 }
46476 resultobj = SWIG_Py_Void();
46477 return resultobj;
46478 fail:
46479 return NULL;
46480 }
46481
46482
46483 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46484 PyObject *resultobj = 0;
46485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46486 wxString *arg2 = 0 ;
46487 void *argp1 = 0 ;
46488 int res1 = 0 ;
46489 bool temp2 = false ;
46490 PyObject * obj0 = 0 ;
46491 PyObject * obj1 = 0 ;
46492 char * kwnames[] = {
46493 (char *) "self",(char *) "str", NULL
46494 };
46495
46496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46498 if (!SWIG_IsOK(res1)) {
46499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46500 }
46501 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46502 {
46503 arg2 = wxString_in_helper(obj1);
46504 if (arg2 == NULL) SWIG_fail;
46505 temp2 = true;
46506 }
46507 {
46508 PyThreadState* __tstate = wxPyBeginAllowThreads();
46509 (arg1)->SetHelp((wxString const &)*arg2);
46510 wxPyEndAllowThreads(__tstate);
46511 if (PyErr_Occurred()) SWIG_fail;
46512 }
46513 resultobj = SWIG_Py_Void();
46514 {
46515 if (temp2)
46516 delete arg2;
46517 }
46518 return resultobj;
46519 fail:
46520 {
46521 if (temp2)
46522 delete arg2;
46523 }
46524 return NULL;
46525 }
46526
46527
46528 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46529 PyObject *resultobj = 0;
46530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46531 wxString *result = 0 ;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 PyObject *swig_obj[1] ;
46535
46536 if (!args) SWIG_fail;
46537 swig_obj[0] = args;
46538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46541 }
46542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 {
46546 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46547 result = (wxString *) &_result_ref;
46548 }
46549 wxPyEndAllowThreads(__tstate);
46550 if (PyErr_Occurred()) SWIG_fail;
46551 }
46552 {
46553 #if wxUSE_UNICODE
46554 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46555 #else
46556 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46557 #endif
46558 }
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46566 PyObject *resultobj = 0;
46567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46568 wxAcceleratorEntry *result = 0 ;
46569 void *argp1 = 0 ;
46570 int res1 = 0 ;
46571 PyObject *swig_obj[1] ;
46572
46573 if (!args) SWIG_fail;
46574 swig_obj[0] = args;
46575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46576 if (!SWIG_IsOK(res1)) {
46577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46578 }
46579 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46580 {
46581 PyThreadState* __tstate = wxPyBeginAllowThreads();
46582 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46583 wxPyEndAllowThreads(__tstate);
46584 if (PyErr_Occurred()) SWIG_fail;
46585 }
46586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46587 return resultobj;
46588 fail:
46589 return NULL;
46590 }
46591
46592
46593 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46594 PyObject *resultobj = 0;
46595 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46596 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46597 void *argp1 = 0 ;
46598 int res1 = 0 ;
46599 void *argp2 = 0 ;
46600 int res2 = 0 ;
46601 PyObject * obj0 = 0 ;
46602 PyObject * obj1 = 0 ;
46603 char * kwnames[] = {
46604 (char *) "self",(char *) "accel", NULL
46605 };
46606
46607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46609 if (!SWIG_IsOK(res1)) {
46610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46611 }
46612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46614 if (!SWIG_IsOK(res2)) {
46615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46616 }
46617 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 (arg1)->SetAccel(arg2);
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 resultobj = SWIG_Py_Void();
46625 return resultobj;
46626 fail:
46627 return NULL;
46628 }
46629
46630
46631 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46632 PyObject *resultobj = 0;
46633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46634 wxBitmap *arg2 = 0 ;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 void *argp2 = 0 ;
46638 int res2 = 0 ;
46639 PyObject * obj0 = 0 ;
46640 PyObject * obj1 = 0 ;
46641 char * kwnames[] = {
46642 (char *) "self",(char *) "bitmap", NULL
46643 };
46644
46645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46647 if (!SWIG_IsOK(res1)) {
46648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46649 }
46650 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46652 if (!SWIG_IsOK(res2)) {
46653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46654 }
46655 if (!argp2) {
46656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46657 }
46658 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46659 {
46660 PyThreadState* __tstate = wxPyBeginAllowThreads();
46661 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46662 wxPyEndAllowThreads(__tstate);
46663 if (PyErr_Occurred()) SWIG_fail;
46664 }
46665 resultobj = SWIG_Py_Void();
46666 return resultobj;
46667 fail:
46668 return NULL;
46669 }
46670
46671
46672 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46673 PyObject *resultobj = 0;
46674 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46675 wxBitmap *result = 0 ;
46676 void *argp1 = 0 ;
46677 int res1 = 0 ;
46678 PyObject *swig_obj[1] ;
46679
46680 if (!args) SWIG_fail;
46681 swig_obj[0] = args;
46682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46683 if (!SWIG_IsOK(res1)) {
46684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46685 }
46686 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46687 {
46688 PyThreadState* __tstate = wxPyBeginAllowThreads();
46689 {
46690 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46691 result = (wxBitmap *) &_result_ref;
46692 }
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 {
46697 wxBitmap* resultptr = new wxBitmap(*result);
46698 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46699 }
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46709 wxFont *arg2 = 0 ;
46710 void *argp1 = 0 ;
46711 int res1 = 0 ;
46712 void *argp2 = 0 ;
46713 int res2 = 0 ;
46714 PyObject * obj0 = 0 ;
46715 PyObject * obj1 = 0 ;
46716 char * kwnames[] = {
46717 (char *) "self",(char *) "font", NULL
46718 };
46719
46720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46722 if (!SWIG_IsOK(res1)) {
46723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46724 }
46725 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46727 if (!SWIG_IsOK(res2)) {
46728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46729 }
46730 if (!argp2) {
46731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46732 }
46733 arg2 = reinterpret_cast< wxFont * >(argp2);
46734 {
46735 PyThreadState* __tstate = wxPyBeginAllowThreads();
46736 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46737 wxPyEndAllowThreads(__tstate);
46738 if (PyErr_Occurred()) SWIG_fail;
46739 }
46740 resultobj = SWIG_Py_Void();
46741 return resultobj;
46742 fail:
46743 return NULL;
46744 }
46745
46746
46747 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46748 PyObject *resultobj = 0;
46749 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46750 wxFont result;
46751 void *argp1 = 0 ;
46752 int res1 = 0 ;
46753 PyObject *swig_obj[1] ;
46754
46755 if (!args) SWIG_fail;
46756 swig_obj[0] = args;
46757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46758 if (!SWIG_IsOK(res1)) {
46759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46760 }
46761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46762 {
46763 PyThreadState* __tstate = wxPyBeginAllowThreads();
46764 result = wxMenuItem_GetFont(arg1);
46765 wxPyEndAllowThreads(__tstate);
46766 if (PyErr_Occurred()) SWIG_fail;
46767 }
46768 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46769 return resultobj;
46770 fail:
46771 return NULL;
46772 }
46773
46774
46775 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46776 PyObject *resultobj = 0;
46777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46778 wxColour *arg2 = 0 ;
46779 void *argp1 = 0 ;
46780 int res1 = 0 ;
46781 wxColour temp2 ;
46782 PyObject * obj0 = 0 ;
46783 PyObject * obj1 = 0 ;
46784 char * kwnames[] = {
46785 (char *) "self",(char *) "colText", NULL
46786 };
46787
46788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46790 if (!SWIG_IsOK(res1)) {
46791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46792 }
46793 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46794 {
46795 arg2 = &temp2;
46796 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46797 }
46798 {
46799 PyThreadState* __tstate = wxPyBeginAllowThreads();
46800 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46801 wxPyEndAllowThreads(__tstate);
46802 if (PyErr_Occurred()) SWIG_fail;
46803 }
46804 resultobj = SWIG_Py_Void();
46805 return resultobj;
46806 fail:
46807 return NULL;
46808 }
46809
46810
46811 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46812 PyObject *resultobj = 0;
46813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46814 wxColour result;
46815 void *argp1 = 0 ;
46816 int res1 = 0 ;
46817 PyObject *swig_obj[1] ;
46818
46819 if (!args) SWIG_fail;
46820 swig_obj[0] = args;
46821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46824 }
46825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46826 {
46827 PyThreadState* __tstate = wxPyBeginAllowThreads();
46828 result = wxMenuItem_GetTextColour(arg1);
46829 wxPyEndAllowThreads(__tstate);
46830 if (PyErr_Occurred()) SWIG_fail;
46831 }
46832 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46833 return resultobj;
46834 fail:
46835 return NULL;
46836 }
46837
46838
46839 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46840 PyObject *resultobj = 0;
46841 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46842 wxColour *arg2 = 0 ;
46843 void *argp1 = 0 ;
46844 int res1 = 0 ;
46845 wxColour temp2 ;
46846 PyObject * obj0 = 0 ;
46847 PyObject * obj1 = 0 ;
46848 char * kwnames[] = {
46849 (char *) "self",(char *) "colBack", NULL
46850 };
46851
46852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46854 if (!SWIG_IsOK(res1)) {
46855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46856 }
46857 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46858 {
46859 arg2 = &temp2;
46860 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46861 }
46862 {
46863 PyThreadState* __tstate = wxPyBeginAllowThreads();
46864 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46865 wxPyEndAllowThreads(__tstate);
46866 if (PyErr_Occurred()) SWIG_fail;
46867 }
46868 resultobj = SWIG_Py_Void();
46869 return resultobj;
46870 fail:
46871 return NULL;
46872 }
46873
46874
46875 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46876 PyObject *resultobj = 0;
46877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46878 wxColour result;
46879 void *argp1 = 0 ;
46880 int res1 = 0 ;
46881 PyObject *swig_obj[1] ;
46882
46883 if (!args) SWIG_fail;
46884 swig_obj[0] = args;
46885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46886 if (!SWIG_IsOK(res1)) {
46887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46888 }
46889 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46890 {
46891 PyThreadState* __tstate = wxPyBeginAllowThreads();
46892 result = wxMenuItem_GetBackgroundColour(arg1);
46893 wxPyEndAllowThreads(__tstate);
46894 if (PyErr_Occurred()) SWIG_fail;
46895 }
46896 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46897 return resultobj;
46898 fail:
46899 return NULL;
46900 }
46901
46902
46903 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46904 PyObject *resultobj = 0;
46905 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46906 wxBitmap *arg2 = 0 ;
46907 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46908 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46909 void *argp1 = 0 ;
46910 int res1 = 0 ;
46911 void *argp2 = 0 ;
46912 int res2 = 0 ;
46913 void *argp3 = 0 ;
46914 int res3 = 0 ;
46915 PyObject * obj0 = 0 ;
46916 PyObject * obj1 = 0 ;
46917 PyObject * obj2 = 0 ;
46918 char * kwnames[] = {
46919 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46920 };
46921
46922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46924 if (!SWIG_IsOK(res1)) {
46925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46926 }
46927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46929 if (!SWIG_IsOK(res2)) {
46930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46931 }
46932 if (!argp2) {
46933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46934 }
46935 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46936 if (obj2) {
46937 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46938 if (!SWIG_IsOK(res3)) {
46939 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46940 }
46941 if (!argp3) {
46942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46943 }
46944 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46945 }
46946 {
46947 PyThreadState* __tstate = wxPyBeginAllowThreads();
46948 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46949 wxPyEndAllowThreads(__tstate);
46950 if (PyErr_Occurred()) SWIG_fail;
46951 }
46952 resultobj = SWIG_Py_Void();
46953 return resultobj;
46954 fail:
46955 return NULL;
46956 }
46957
46958
46959 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46960 PyObject *resultobj = 0;
46961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46962 wxBitmap *arg2 = 0 ;
46963 void *argp1 = 0 ;
46964 int res1 = 0 ;
46965 void *argp2 = 0 ;
46966 int res2 = 0 ;
46967 PyObject * obj0 = 0 ;
46968 PyObject * obj1 = 0 ;
46969 char * kwnames[] = {
46970 (char *) "self",(char *) "bmpDisabled", NULL
46971 };
46972
46973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46975 if (!SWIG_IsOK(res1)) {
46976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46977 }
46978 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46980 if (!SWIG_IsOK(res2)) {
46981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46982 }
46983 if (!argp2) {
46984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46985 }
46986 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46987 {
46988 PyThreadState* __tstate = wxPyBeginAllowThreads();
46989 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46990 wxPyEndAllowThreads(__tstate);
46991 if (PyErr_Occurred()) SWIG_fail;
46992 }
46993 resultobj = SWIG_Py_Void();
46994 return resultobj;
46995 fail:
46996 return NULL;
46997 }
46998
46999
47000 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47001 PyObject *resultobj = 0;
47002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47003 wxBitmap *result = 0 ;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 PyObject *swig_obj[1] ;
47007
47008 if (!args) SWIG_fail;
47009 swig_obj[0] = args;
47010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47011 if (!SWIG_IsOK(res1)) {
47012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47013 }
47014 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47015 {
47016 PyThreadState* __tstate = wxPyBeginAllowThreads();
47017 {
47018 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47019 result = (wxBitmap *) &_result_ref;
47020 }
47021 wxPyEndAllowThreads(__tstate);
47022 if (PyErr_Occurred()) SWIG_fail;
47023 }
47024 {
47025 wxBitmap* resultptr = new wxBitmap(*result);
47026 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47027 }
47028 return resultobj;
47029 fail:
47030 return NULL;
47031 }
47032
47033
47034 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47035 PyObject *resultobj = 0;
47036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47037 int arg2 ;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 int val2 ;
47041 int ecode2 = 0 ;
47042 PyObject * obj0 = 0 ;
47043 PyObject * obj1 = 0 ;
47044 char * kwnames[] = {
47045 (char *) "self",(char *) "nWidth", NULL
47046 };
47047
47048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47050 if (!SWIG_IsOK(res1)) {
47051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47052 }
47053 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47054 ecode2 = SWIG_AsVal_int(obj1, &val2);
47055 if (!SWIG_IsOK(ecode2)) {
47056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47057 }
47058 arg2 = static_cast< int >(val2);
47059 {
47060 PyThreadState* __tstate = wxPyBeginAllowThreads();
47061 wxMenuItem_SetMarginWidth(arg1,arg2);
47062 wxPyEndAllowThreads(__tstate);
47063 if (PyErr_Occurred()) SWIG_fail;
47064 }
47065 resultobj = SWIG_Py_Void();
47066 return resultobj;
47067 fail:
47068 return NULL;
47069 }
47070
47071
47072 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47073 PyObject *resultobj = 0;
47074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47075 int result;
47076 void *argp1 = 0 ;
47077 int res1 = 0 ;
47078 PyObject *swig_obj[1] ;
47079
47080 if (!args) SWIG_fail;
47081 swig_obj[0] = args;
47082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47083 if (!SWIG_IsOK(res1)) {
47084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47085 }
47086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47087 {
47088 PyThreadState* __tstate = wxPyBeginAllowThreads();
47089 result = (int)wxMenuItem_GetMarginWidth(arg1);
47090 wxPyEndAllowThreads(__tstate);
47091 if (PyErr_Occurred()) SWIG_fail;
47092 }
47093 resultobj = SWIG_From_int(static_cast< int >(result));
47094 return resultobj;
47095 fail:
47096 return NULL;
47097 }
47098
47099
47100 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47101 PyObject *resultobj = 0;
47102 int result;
47103
47104 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47105 {
47106 PyThreadState* __tstate = wxPyBeginAllowThreads();
47107 result = (int)wxMenuItem_GetDefaultMarginWidth();
47108 wxPyEndAllowThreads(__tstate);
47109 if (PyErr_Occurred()) SWIG_fail;
47110 }
47111 resultobj = SWIG_From_int(static_cast< int >(result));
47112 return resultobj;
47113 fail:
47114 return NULL;
47115 }
47116
47117
47118 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47119 PyObject *resultobj = 0;
47120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47121 bool result;
47122 void *argp1 = 0 ;
47123 int res1 = 0 ;
47124 PyObject *swig_obj[1] ;
47125
47126 if (!args) SWIG_fail;
47127 swig_obj[0] = args;
47128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47129 if (!SWIG_IsOK(res1)) {
47130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47131 }
47132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47133 {
47134 PyThreadState* __tstate = wxPyBeginAllowThreads();
47135 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47136 wxPyEndAllowThreads(__tstate);
47137 if (PyErr_Occurred()) SWIG_fail;
47138 }
47139 {
47140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47141 }
47142 return resultobj;
47143 fail:
47144 return NULL;
47145 }
47146
47147
47148 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47149 PyObject *resultobj = 0;
47150 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47151 bool arg2 = (bool) true ;
47152 void *argp1 = 0 ;
47153 int res1 = 0 ;
47154 bool val2 ;
47155 int ecode2 = 0 ;
47156 PyObject * obj0 = 0 ;
47157 PyObject * obj1 = 0 ;
47158 char * kwnames[] = {
47159 (char *) "self",(char *) "ownerDrawn", NULL
47160 };
47161
47162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47164 if (!SWIG_IsOK(res1)) {
47165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47166 }
47167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47168 if (obj1) {
47169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47170 if (!SWIG_IsOK(ecode2)) {
47171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47172 }
47173 arg2 = static_cast< bool >(val2);
47174 }
47175 {
47176 PyThreadState* __tstate = wxPyBeginAllowThreads();
47177 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47178 wxPyEndAllowThreads(__tstate);
47179 if (PyErr_Occurred()) SWIG_fail;
47180 }
47181 resultobj = SWIG_Py_Void();
47182 return resultobj;
47183 fail:
47184 return NULL;
47185 }
47186
47187
47188 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47189 PyObject *resultobj = 0;
47190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47191 void *argp1 = 0 ;
47192 int res1 = 0 ;
47193 PyObject *swig_obj[1] ;
47194
47195 if (!args) SWIG_fail;
47196 swig_obj[0] = args;
47197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47198 if (!SWIG_IsOK(res1)) {
47199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47200 }
47201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47202 {
47203 PyThreadState* __tstate = wxPyBeginAllowThreads();
47204 wxMenuItem_ResetOwnerDrawn(arg1);
47205 wxPyEndAllowThreads(__tstate);
47206 if (PyErr_Occurred()) SWIG_fail;
47207 }
47208 resultobj = SWIG_Py_Void();
47209 return resultobj;
47210 fail:
47211 return NULL;
47212 }
47213
47214
47215 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47216 PyObject *obj;
47217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47218 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47219 return SWIG_Py_Void();
47220 }
47221
47222 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47223 return SWIG_Python_InitShadowInstance(args);
47224 }
47225
47226 SWIGINTERN int ControlNameStr_set(PyObject *) {
47227 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47228 return 1;
47229 }
47230
47231
47232 SWIGINTERN PyObject *ControlNameStr_get(void) {
47233 PyObject *pyobj = 0;
47234
47235 {
47236 #if wxUSE_UNICODE
47237 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47238 #else
47239 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47240 #endif
47241 }
47242 return pyobj;
47243 }
47244
47245
47246 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47247 PyObject *resultobj = 0;
47248 wxWindow *arg1 = (wxWindow *) 0 ;
47249 int arg2 = (int) -1 ;
47250 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47251 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47252 wxSize const &arg4_defvalue = wxDefaultSize ;
47253 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47254 long arg5 = (long) 0 ;
47255 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47256 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47257 wxString const &arg7_defvalue = wxPyControlNameStr ;
47258 wxString *arg7 = (wxString *) &arg7_defvalue ;
47259 wxControl *result = 0 ;
47260 void *argp1 = 0 ;
47261 int res1 = 0 ;
47262 int val2 ;
47263 int ecode2 = 0 ;
47264 wxPoint temp3 ;
47265 wxSize temp4 ;
47266 long val5 ;
47267 int ecode5 = 0 ;
47268 void *argp6 = 0 ;
47269 int res6 = 0 ;
47270 bool temp7 = false ;
47271 PyObject * obj0 = 0 ;
47272 PyObject * obj1 = 0 ;
47273 PyObject * obj2 = 0 ;
47274 PyObject * obj3 = 0 ;
47275 PyObject * obj4 = 0 ;
47276 PyObject * obj5 = 0 ;
47277 PyObject * obj6 = 0 ;
47278 char * kwnames[] = {
47279 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47280 };
47281
47282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47284 if (!SWIG_IsOK(res1)) {
47285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47286 }
47287 arg1 = reinterpret_cast< wxWindow * >(argp1);
47288 if (obj1) {
47289 ecode2 = SWIG_AsVal_int(obj1, &val2);
47290 if (!SWIG_IsOK(ecode2)) {
47291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47292 }
47293 arg2 = static_cast< int >(val2);
47294 }
47295 if (obj2) {
47296 {
47297 arg3 = &temp3;
47298 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47299 }
47300 }
47301 if (obj3) {
47302 {
47303 arg4 = &temp4;
47304 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47305 }
47306 }
47307 if (obj4) {
47308 ecode5 = SWIG_AsVal_long(obj4, &val5);
47309 if (!SWIG_IsOK(ecode5)) {
47310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47311 }
47312 arg5 = static_cast< long >(val5);
47313 }
47314 if (obj5) {
47315 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47316 if (!SWIG_IsOK(res6)) {
47317 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47318 }
47319 if (!argp6) {
47320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47321 }
47322 arg6 = reinterpret_cast< wxValidator * >(argp6);
47323 }
47324 if (obj6) {
47325 {
47326 arg7 = wxString_in_helper(obj6);
47327 if (arg7 == NULL) SWIG_fail;
47328 temp7 = true;
47329 }
47330 }
47331 {
47332 if (!wxPyCheckForApp()) SWIG_fail;
47333 PyThreadState* __tstate = wxPyBeginAllowThreads();
47334 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47335 wxPyEndAllowThreads(__tstate);
47336 if (PyErr_Occurred()) SWIG_fail;
47337 }
47338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47339 {
47340 if (temp7)
47341 delete arg7;
47342 }
47343 return resultobj;
47344 fail:
47345 {
47346 if (temp7)
47347 delete arg7;
47348 }
47349 return NULL;
47350 }
47351
47352
47353 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47354 PyObject *resultobj = 0;
47355 wxControl *result = 0 ;
47356
47357 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47358 {
47359 if (!wxPyCheckForApp()) SWIG_fail;
47360 PyThreadState* __tstate = wxPyBeginAllowThreads();
47361 result = (wxControl *)new wxControl();
47362 wxPyEndAllowThreads(__tstate);
47363 if (PyErr_Occurred()) SWIG_fail;
47364 }
47365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47366 return resultobj;
47367 fail:
47368 return NULL;
47369 }
47370
47371
47372 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47373 PyObject *resultobj = 0;
47374 wxControl *arg1 = (wxControl *) 0 ;
47375 wxWindow *arg2 = (wxWindow *) 0 ;
47376 int arg3 = (int) -1 ;
47377 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47378 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47379 wxSize const &arg5_defvalue = wxDefaultSize ;
47380 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47381 long arg6 = (long) 0 ;
47382 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47383 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47384 wxString const &arg8_defvalue = wxPyControlNameStr ;
47385 wxString *arg8 = (wxString *) &arg8_defvalue ;
47386 bool result;
47387 void *argp1 = 0 ;
47388 int res1 = 0 ;
47389 void *argp2 = 0 ;
47390 int res2 = 0 ;
47391 int val3 ;
47392 int ecode3 = 0 ;
47393 wxPoint temp4 ;
47394 wxSize temp5 ;
47395 long val6 ;
47396 int ecode6 = 0 ;
47397 void *argp7 = 0 ;
47398 int res7 = 0 ;
47399 bool temp8 = false ;
47400 PyObject * obj0 = 0 ;
47401 PyObject * obj1 = 0 ;
47402 PyObject * obj2 = 0 ;
47403 PyObject * obj3 = 0 ;
47404 PyObject * obj4 = 0 ;
47405 PyObject * obj5 = 0 ;
47406 PyObject * obj6 = 0 ;
47407 PyObject * obj7 = 0 ;
47408 char * kwnames[] = {
47409 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47410 };
47411
47412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47414 if (!SWIG_IsOK(res1)) {
47415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47416 }
47417 arg1 = reinterpret_cast< wxControl * >(argp1);
47418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47419 if (!SWIG_IsOK(res2)) {
47420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47421 }
47422 arg2 = reinterpret_cast< wxWindow * >(argp2);
47423 if (obj2) {
47424 ecode3 = SWIG_AsVal_int(obj2, &val3);
47425 if (!SWIG_IsOK(ecode3)) {
47426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47427 }
47428 arg3 = static_cast< int >(val3);
47429 }
47430 if (obj3) {
47431 {
47432 arg4 = &temp4;
47433 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47434 }
47435 }
47436 if (obj4) {
47437 {
47438 arg5 = &temp5;
47439 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47440 }
47441 }
47442 if (obj5) {
47443 ecode6 = SWIG_AsVal_long(obj5, &val6);
47444 if (!SWIG_IsOK(ecode6)) {
47445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47446 }
47447 arg6 = static_cast< long >(val6);
47448 }
47449 if (obj6) {
47450 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47451 if (!SWIG_IsOK(res7)) {
47452 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47453 }
47454 if (!argp7) {
47455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47456 }
47457 arg7 = reinterpret_cast< wxValidator * >(argp7);
47458 }
47459 if (obj7) {
47460 {
47461 arg8 = wxString_in_helper(obj7);
47462 if (arg8 == NULL) SWIG_fail;
47463 temp8 = true;
47464 }
47465 }
47466 {
47467 PyThreadState* __tstate = wxPyBeginAllowThreads();
47468 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47469 wxPyEndAllowThreads(__tstate);
47470 if (PyErr_Occurred()) SWIG_fail;
47471 }
47472 {
47473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47474 }
47475 {
47476 if (temp8)
47477 delete arg8;
47478 }
47479 return resultobj;
47480 fail:
47481 {
47482 if (temp8)
47483 delete arg8;
47484 }
47485 return NULL;
47486 }
47487
47488
47489 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47490 PyObject *resultobj = 0;
47491 wxControl *arg1 = (wxControl *) 0 ;
47492 int result;
47493 void *argp1 = 0 ;
47494 int res1 = 0 ;
47495 PyObject *swig_obj[1] ;
47496
47497 if (!args) SWIG_fail;
47498 swig_obj[0] = args;
47499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47500 if (!SWIG_IsOK(res1)) {
47501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47502 }
47503 arg1 = reinterpret_cast< wxControl * >(argp1);
47504 {
47505 PyThreadState* __tstate = wxPyBeginAllowThreads();
47506 result = (int)((wxControl const *)arg1)->GetAlignment();
47507 wxPyEndAllowThreads(__tstate);
47508 if (PyErr_Occurred()) SWIG_fail;
47509 }
47510 resultobj = SWIG_From_int(static_cast< int >(result));
47511 return resultobj;
47512 fail:
47513 return NULL;
47514 }
47515
47516
47517 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47518 PyObject *resultobj = 0;
47519 wxControl *arg1 = (wxControl *) 0 ;
47520 wxString result;
47521 void *argp1 = 0 ;
47522 int res1 = 0 ;
47523 PyObject *swig_obj[1] ;
47524
47525 if (!args) SWIG_fail;
47526 swig_obj[0] = args;
47527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47528 if (!SWIG_IsOK(res1)) {
47529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47530 }
47531 arg1 = reinterpret_cast< wxControl * >(argp1);
47532 {
47533 PyThreadState* __tstate = wxPyBeginAllowThreads();
47534 result = ((wxControl const *)arg1)->GetLabelText();
47535 wxPyEndAllowThreads(__tstate);
47536 if (PyErr_Occurred()) SWIG_fail;
47537 }
47538 {
47539 #if wxUSE_UNICODE
47540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47541 #else
47542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47543 #endif
47544 }
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47552 PyObject *resultobj = 0;
47553 wxControl *arg1 = (wxControl *) 0 ;
47554 wxCommandEvent *arg2 = 0 ;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 void *argp2 = 0 ;
47558 int res2 = 0 ;
47559 PyObject * obj0 = 0 ;
47560 PyObject * obj1 = 0 ;
47561 char * kwnames[] = {
47562 (char *) "self",(char *) "event", NULL
47563 };
47564
47565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47567 if (!SWIG_IsOK(res1)) {
47568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47569 }
47570 arg1 = reinterpret_cast< wxControl * >(argp1);
47571 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47572 if (!SWIG_IsOK(res2)) {
47573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47574 }
47575 if (!argp2) {
47576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47577 }
47578 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47579 {
47580 PyThreadState* __tstate = wxPyBeginAllowThreads();
47581 (arg1)->Command(*arg2);
47582 wxPyEndAllowThreads(__tstate);
47583 if (PyErr_Occurred()) SWIG_fail;
47584 }
47585 resultobj = SWIG_Py_Void();
47586 return resultobj;
47587 fail:
47588 return NULL;
47589 }
47590
47591
47592 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47593 PyObject *resultobj = 0;
47594 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47595 SwigValueWrapper<wxVisualAttributes > result;
47596 int val1 ;
47597 int ecode1 = 0 ;
47598 PyObject * obj0 = 0 ;
47599 char * kwnames[] = {
47600 (char *) "variant", NULL
47601 };
47602
47603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47604 if (obj0) {
47605 ecode1 = SWIG_AsVal_int(obj0, &val1);
47606 if (!SWIG_IsOK(ecode1)) {
47607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47608 }
47609 arg1 = static_cast< wxWindowVariant >(val1);
47610 }
47611 {
47612 if (!wxPyCheckForApp()) SWIG_fail;
47613 PyThreadState* __tstate = wxPyBeginAllowThreads();
47614 result = wxControl::GetClassDefaultAttributes(arg1);
47615 wxPyEndAllowThreads(__tstate);
47616 if (PyErr_Occurred()) SWIG_fail;
47617 }
47618 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47619 return resultobj;
47620 fail:
47621 return NULL;
47622 }
47623
47624
47625 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47626 PyObject *obj;
47627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47628 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47629 return SWIG_Py_Void();
47630 }
47631
47632 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47633 return SWIG_Python_InitShadowInstance(args);
47634 }
47635
47636 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47637 PyObject *resultobj = 0;
47638 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47639 wxString *arg2 = 0 ;
47640 PyObject *arg3 = (PyObject *) NULL ;
47641 int result;
47642 void *argp1 = 0 ;
47643 int res1 = 0 ;
47644 bool temp2 = false ;
47645 PyObject * obj0 = 0 ;
47646 PyObject * obj1 = 0 ;
47647 PyObject * obj2 = 0 ;
47648 char * kwnames[] = {
47649 (char *) "self",(char *) "item",(char *) "clientData", NULL
47650 };
47651
47652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47654 if (!SWIG_IsOK(res1)) {
47655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47656 }
47657 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47658 {
47659 arg2 = wxString_in_helper(obj1);
47660 if (arg2 == NULL) SWIG_fail;
47661 temp2 = true;
47662 }
47663 if (obj2) {
47664 arg3 = obj2;
47665 }
47666 {
47667 PyThreadState* __tstate = wxPyBeginAllowThreads();
47668 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47669 wxPyEndAllowThreads(__tstate);
47670 if (PyErr_Occurred()) SWIG_fail;
47671 }
47672 resultobj = SWIG_From_int(static_cast< int >(result));
47673 {
47674 if (temp2)
47675 delete arg2;
47676 }
47677 return resultobj;
47678 fail:
47679 {
47680 if (temp2)
47681 delete arg2;
47682 }
47683 return NULL;
47684 }
47685
47686
47687 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47688 PyObject *resultobj = 0;
47689 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47690 wxArrayString *arg2 = 0 ;
47691 void *argp1 = 0 ;
47692 int res1 = 0 ;
47693 bool temp2 = false ;
47694 PyObject * obj0 = 0 ;
47695 PyObject * obj1 = 0 ;
47696 char * kwnames[] = {
47697 (char *) "self",(char *) "strings", NULL
47698 };
47699
47700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47702 if (!SWIG_IsOK(res1)) {
47703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47704 }
47705 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47706 {
47707 if (! PySequence_Check(obj1)) {
47708 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47709 SWIG_fail;
47710 }
47711 arg2 = new wxArrayString;
47712 temp2 = true;
47713 int i, len=PySequence_Length(obj1);
47714 for (i=0; i<len; i++) {
47715 PyObject* item = PySequence_GetItem(obj1, i);
47716 wxString* s = wxString_in_helper(item);
47717 if (PyErr_Occurred()) SWIG_fail;
47718 arg2->Add(*s);
47719 delete s;
47720 Py_DECREF(item);
47721 }
47722 }
47723 {
47724 PyThreadState* __tstate = wxPyBeginAllowThreads();
47725 (arg1)->Append((wxArrayString const &)*arg2);
47726 wxPyEndAllowThreads(__tstate);
47727 if (PyErr_Occurred()) SWIG_fail;
47728 }
47729 resultobj = SWIG_Py_Void();
47730 {
47731 if (temp2) delete arg2;
47732 }
47733 return resultobj;
47734 fail:
47735 {
47736 if (temp2) delete arg2;
47737 }
47738 return NULL;
47739 }
47740
47741
47742 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47743 PyObject *resultobj = 0;
47744 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47745 wxString *arg2 = 0 ;
47746 unsigned int arg3 ;
47747 PyObject *arg4 = (PyObject *) NULL ;
47748 int result;
47749 void *argp1 = 0 ;
47750 int res1 = 0 ;
47751 bool temp2 = false ;
47752 unsigned int val3 ;
47753 int ecode3 = 0 ;
47754 PyObject * obj0 = 0 ;
47755 PyObject * obj1 = 0 ;
47756 PyObject * obj2 = 0 ;
47757 PyObject * obj3 = 0 ;
47758 char * kwnames[] = {
47759 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47760 };
47761
47762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47764 if (!SWIG_IsOK(res1)) {
47765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47766 }
47767 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47768 {
47769 arg2 = wxString_in_helper(obj1);
47770 if (arg2 == NULL) SWIG_fail;
47771 temp2 = true;
47772 }
47773 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47774 if (!SWIG_IsOK(ecode3)) {
47775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47776 }
47777 arg3 = static_cast< unsigned int >(val3);
47778 if (obj3) {
47779 arg4 = obj3;
47780 }
47781 {
47782 PyThreadState* __tstate = wxPyBeginAllowThreads();
47783 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47784 wxPyEndAllowThreads(__tstate);
47785 if (PyErr_Occurred()) SWIG_fail;
47786 }
47787 resultobj = SWIG_From_int(static_cast< int >(result));
47788 {
47789 if (temp2)
47790 delete arg2;
47791 }
47792 return resultobj;
47793 fail:
47794 {
47795 if (temp2)
47796 delete arg2;
47797 }
47798 return NULL;
47799 }
47800
47801
47802 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47803 PyObject *resultobj = 0;
47804 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47805 void *argp1 = 0 ;
47806 int res1 = 0 ;
47807 PyObject *swig_obj[1] ;
47808
47809 if (!args) SWIG_fail;
47810 swig_obj[0] = args;
47811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47812 if (!SWIG_IsOK(res1)) {
47813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47814 }
47815 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47816 {
47817 PyThreadState* __tstate = wxPyBeginAllowThreads();
47818 (arg1)->Clear();
47819 wxPyEndAllowThreads(__tstate);
47820 if (PyErr_Occurred()) SWIG_fail;
47821 }
47822 resultobj = SWIG_Py_Void();
47823 return resultobj;
47824 fail:
47825 return NULL;
47826 }
47827
47828
47829 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47830 PyObject *resultobj = 0;
47831 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47832 unsigned int arg2 ;
47833 void *argp1 = 0 ;
47834 int res1 = 0 ;
47835 unsigned int val2 ;
47836 int ecode2 = 0 ;
47837 PyObject * obj0 = 0 ;
47838 PyObject * obj1 = 0 ;
47839 char * kwnames[] = {
47840 (char *) "self",(char *) "n", NULL
47841 };
47842
47843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47845 if (!SWIG_IsOK(res1)) {
47846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47847 }
47848 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47849 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47850 if (!SWIG_IsOK(ecode2)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47852 }
47853 arg2 = static_cast< unsigned int >(val2);
47854 {
47855 PyThreadState* __tstate = wxPyBeginAllowThreads();
47856 (arg1)->Delete(arg2);
47857 wxPyEndAllowThreads(__tstate);
47858 if (PyErr_Occurred()) SWIG_fail;
47859 }
47860 resultobj = SWIG_Py_Void();
47861 return resultobj;
47862 fail:
47863 return NULL;
47864 }
47865
47866
47867 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47868 PyObject *resultobj = 0;
47869 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47870 unsigned int arg2 ;
47871 PyObject *result = 0 ;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 unsigned int val2 ;
47875 int ecode2 = 0 ;
47876 PyObject * obj0 = 0 ;
47877 PyObject * obj1 = 0 ;
47878 char * kwnames[] = {
47879 (char *) "self",(char *) "n", NULL
47880 };
47881
47882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47884 if (!SWIG_IsOK(res1)) {
47885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47886 }
47887 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47888 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47889 if (!SWIG_IsOK(ecode2)) {
47890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47891 }
47892 arg2 = static_cast< unsigned int >(val2);
47893 {
47894 PyThreadState* __tstate = wxPyBeginAllowThreads();
47895 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47896 wxPyEndAllowThreads(__tstate);
47897 if (PyErr_Occurred()) SWIG_fail;
47898 }
47899 resultobj = result;
47900 return resultobj;
47901 fail:
47902 return NULL;
47903 }
47904
47905
47906 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47907 PyObject *resultobj = 0;
47908 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47909 unsigned int arg2 ;
47910 PyObject *arg3 = (PyObject *) 0 ;
47911 void *argp1 = 0 ;
47912 int res1 = 0 ;
47913 unsigned int val2 ;
47914 int ecode2 = 0 ;
47915 PyObject * obj0 = 0 ;
47916 PyObject * obj1 = 0 ;
47917 PyObject * obj2 = 0 ;
47918 char * kwnames[] = {
47919 (char *) "self",(char *) "n",(char *) "clientData", NULL
47920 };
47921
47922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47924 if (!SWIG_IsOK(res1)) {
47925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47926 }
47927 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47928 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47929 if (!SWIG_IsOK(ecode2)) {
47930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47931 }
47932 arg2 = static_cast< unsigned int >(val2);
47933 arg3 = obj2;
47934 {
47935 PyThreadState* __tstate = wxPyBeginAllowThreads();
47936 wxItemContainer_SetClientData(arg1,arg2,arg3);
47937 wxPyEndAllowThreads(__tstate);
47938 if (PyErr_Occurred()) SWIG_fail;
47939 }
47940 resultobj = SWIG_Py_Void();
47941 return resultobj;
47942 fail:
47943 return NULL;
47944 }
47945
47946
47947 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47948 PyObject *resultobj = 0;
47949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47950 unsigned int result;
47951 void *argp1 = 0 ;
47952 int res1 = 0 ;
47953 PyObject *swig_obj[1] ;
47954
47955 if (!args) SWIG_fail;
47956 swig_obj[0] = args;
47957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47958 if (!SWIG_IsOK(res1)) {
47959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47960 }
47961 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47962 {
47963 PyThreadState* __tstate = wxPyBeginAllowThreads();
47964 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47965 wxPyEndAllowThreads(__tstate);
47966 if (PyErr_Occurred()) SWIG_fail;
47967 }
47968 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47969 return resultobj;
47970 fail:
47971 return NULL;
47972 }
47973
47974
47975 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47976 PyObject *resultobj = 0;
47977 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47978 bool result;
47979 void *argp1 = 0 ;
47980 int res1 = 0 ;
47981 PyObject *swig_obj[1] ;
47982
47983 if (!args) SWIG_fail;
47984 swig_obj[0] = args;
47985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47986 if (!SWIG_IsOK(res1)) {
47987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47988 }
47989 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 {
47997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47998 }
47999 return resultobj;
48000 fail:
48001 return NULL;
48002 }
48003
48004
48005 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48006 PyObject *resultobj = 0;
48007 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48008 unsigned int arg2 ;
48009 wxString result;
48010 void *argp1 = 0 ;
48011 int res1 = 0 ;
48012 unsigned int val2 ;
48013 int ecode2 = 0 ;
48014 PyObject * obj0 = 0 ;
48015 PyObject * obj1 = 0 ;
48016 char * kwnames[] = {
48017 (char *) "self",(char *) "n", NULL
48018 };
48019
48020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48022 if (!SWIG_IsOK(res1)) {
48023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48024 }
48025 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48026 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48027 if (!SWIG_IsOK(ecode2)) {
48028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48029 }
48030 arg2 = static_cast< unsigned int >(val2);
48031 {
48032 PyThreadState* __tstate = wxPyBeginAllowThreads();
48033 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48034 wxPyEndAllowThreads(__tstate);
48035 if (PyErr_Occurred()) SWIG_fail;
48036 }
48037 {
48038 #if wxUSE_UNICODE
48039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48040 #else
48041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48042 #endif
48043 }
48044 return resultobj;
48045 fail:
48046 return NULL;
48047 }
48048
48049
48050 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48051 PyObject *resultobj = 0;
48052 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48053 wxArrayString result;
48054 void *argp1 = 0 ;
48055 int res1 = 0 ;
48056 PyObject *swig_obj[1] ;
48057
48058 if (!args) SWIG_fail;
48059 swig_obj[0] = args;
48060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48063 }
48064 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48065 {
48066 PyThreadState* __tstate = wxPyBeginAllowThreads();
48067 result = ((wxItemContainer const *)arg1)->GetStrings();
48068 wxPyEndAllowThreads(__tstate);
48069 if (PyErr_Occurred()) SWIG_fail;
48070 }
48071 {
48072 resultobj = wxArrayString2PyList_helper(result);
48073 }
48074 return resultobj;
48075 fail:
48076 return NULL;
48077 }
48078
48079
48080 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48081 PyObject *resultobj = 0;
48082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48083 unsigned int arg2 ;
48084 wxString *arg3 = 0 ;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 unsigned int val2 ;
48088 int ecode2 = 0 ;
48089 bool temp3 = false ;
48090 PyObject * obj0 = 0 ;
48091 PyObject * obj1 = 0 ;
48092 PyObject * obj2 = 0 ;
48093 char * kwnames[] = {
48094 (char *) "self",(char *) "n",(char *) "s", NULL
48095 };
48096
48097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48099 if (!SWIG_IsOK(res1)) {
48100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48101 }
48102 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48103 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48104 if (!SWIG_IsOK(ecode2)) {
48105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48106 }
48107 arg2 = static_cast< unsigned int >(val2);
48108 {
48109 arg3 = wxString_in_helper(obj2);
48110 if (arg3 == NULL) SWIG_fail;
48111 temp3 = true;
48112 }
48113 {
48114 PyThreadState* __tstate = wxPyBeginAllowThreads();
48115 (arg1)->SetString(arg2,(wxString const &)*arg3);
48116 wxPyEndAllowThreads(__tstate);
48117 if (PyErr_Occurred()) SWIG_fail;
48118 }
48119 resultobj = SWIG_Py_Void();
48120 {
48121 if (temp3)
48122 delete arg3;
48123 }
48124 return resultobj;
48125 fail:
48126 {
48127 if (temp3)
48128 delete arg3;
48129 }
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48135 PyObject *resultobj = 0;
48136 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48137 wxString *arg2 = 0 ;
48138 int result;
48139 void *argp1 = 0 ;
48140 int res1 = 0 ;
48141 bool temp2 = false ;
48142 PyObject * obj0 = 0 ;
48143 PyObject * obj1 = 0 ;
48144 char * kwnames[] = {
48145 (char *) "self",(char *) "s", NULL
48146 };
48147
48148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48150 if (!SWIG_IsOK(res1)) {
48151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48152 }
48153 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48154 {
48155 arg2 = wxString_in_helper(obj1);
48156 if (arg2 == NULL) SWIG_fail;
48157 temp2 = true;
48158 }
48159 {
48160 PyThreadState* __tstate = wxPyBeginAllowThreads();
48161 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48162 wxPyEndAllowThreads(__tstate);
48163 if (PyErr_Occurred()) SWIG_fail;
48164 }
48165 resultobj = SWIG_From_int(static_cast< int >(result));
48166 {
48167 if (temp2)
48168 delete arg2;
48169 }
48170 return resultobj;
48171 fail:
48172 {
48173 if (temp2)
48174 delete arg2;
48175 }
48176 return NULL;
48177 }
48178
48179
48180 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48181 PyObject *resultobj = 0;
48182 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48183 int arg2 ;
48184 void *argp1 = 0 ;
48185 int res1 = 0 ;
48186 int val2 ;
48187 int ecode2 = 0 ;
48188 PyObject * obj0 = 0 ;
48189 PyObject * obj1 = 0 ;
48190 char * kwnames[] = {
48191 (char *) "self",(char *) "n", NULL
48192 };
48193
48194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48200 ecode2 = SWIG_AsVal_int(obj1, &val2);
48201 if (!SWIG_IsOK(ecode2)) {
48202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48203 }
48204 arg2 = static_cast< int >(val2);
48205 {
48206 PyThreadState* __tstate = wxPyBeginAllowThreads();
48207 (arg1)->SetSelection(arg2);
48208 wxPyEndAllowThreads(__tstate);
48209 if (PyErr_Occurred()) SWIG_fail;
48210 }
48211 resultobj = SWIG_Py_Void();
48212 return resultobj;
48213 fail:
48214 return NULL;
48215 }
48216
48217
48218 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48219 PyObject *resultobj = 0;
48220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48221 int result;
48222 void *argp1 = 0 ;
48223 int res1 = 0 ;
48224 PyObject *swig_obj[1] ;
48225
48226 if (!args) SWIG_fail;
48227 swig_obj[0] = args;
48228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48231 }
48232 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48233 {
48234 PyThreadState* __tstate = wxPyBeginAllowThreads();
48235 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48236 wxPyEndAllowThreads(__tstate);
48237 if (PyErr_Occurred()) SWIG_fail;
48238 }
48239 resultobj = SWIG_From_int(static_cast< int >(result));
48240 return resultobj;
48241 fail:
48242 return NULL;
48243 }
48244
48245
48246 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48247 PyObject *resultobj = 0;
48248 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48249 wxString *arg2 = 0 ;
48250 bool result;
48251 void *argp1 = 0 ;
48252 int res1 = 0 ;
48253 bool temp2 = false ;
48254 PyObject * obj0 = 0 ;
48255 PyObject * obj1 = 0 ;
48256 char * kwnames[] = {
48257 (char *) "self",(char *) "s", NULL
48258 };
48259
48260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48262 if (!SWIG_IsOK(res1)) {
48263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48264 }
48265 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48266 {
48267 arg2 = wxString_in_helper(obj1);
48268 if (arg2 == NULL) SWIG_fail;
48269 temp2 = true;
48270 }
48271 {
48272 PyThreadState* __tstate = wxPyBeginAllowThreads();
48273 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48274 wxPyEndAllowThreads(__tstate);
48275 if (PyErr_Occurred()) SWIG_fail;
48276 }
48277 {
48278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48279 }
48280 {
48281 if (temp2)
48282 delete arg2;
48283 }
48284 return resultobj;
48285 fail:
48286 {
48287 if (temp2)
48288 delete arg2;
48289 }
48290 return NULL;
48291 }
48292
48293
48294 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48295 PyObject *resultobj = 0;
48296 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48297 wxString result;
48298 void *argp1 = 0 ;
48299 int res1 = 0 ;
48300 PyObject *swig_obj[1] ;
48301
48302 if (!args) SWIG_fail;
48303 swig_obj[0] = args;
48304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48307 }
48308 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48309 {
48310 PyThreadState* __tstate = wxPyBeginAllowThreads();
48311 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48312 wxPyEndAllowThreads(__tstate);
48313 if (PyErr_Occurred()) SWIG_fail;
48314 }
48315 {
48316 #if wxUSE_UNICODE
48317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48318 #else
48319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48320 #endif
48321 }
48322 return resultobj;
48323 fail:
48324 return NULL;
48325 }
48326
48327
48328 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48329 PyObject *resultobj = 0;
48330 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48331 int arg2 ;
48332 void *argp1 = 0 ;
48333 int res1 = 0 ;
48334 int val2 ;
48335 int ecode2 = 0 ;
48336 PyObject * obj0 = 0 ;
48337 PyObject * obj1 = 0 ;
48338 char * kwnames[] = {
48339 (char *) "self",(char *) "n", NULL
48340 };
48341
48342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48344 if (!SWIG_IsOK(res1)) {
48345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48346 }
48347 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48348 ecode2 = SWIG_AsVal_int(obj1, &val2);
48349 if (!SWIG_IsOK(ecode2)) {
48350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48351 }
48352 arg2 = static_cast< int >(val2);
48353 {
48354 PyThreadState* __tstate = wxPyBeginAllowThreads();
48355 (arg1)->Select(arg2);
48356 wxPyEndAllowThreads(__tstate);
48357 if (PyErr_Occurred()) SWIG_fail;
48358 }
48359 resultobj = SWIG_Py_Void();
48360 return resultobj;
48361 fail:
48362 return NULL;
48363 }
48364
48365
48366 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48367 PyObject *obj;
48368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48369 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48370 return SWIG_Py_Void();
48371 }
48372
48373 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48374 PyObject *obj;
48375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48376 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48377 return SWIG_Py_Void();
48378 }
48379
48380 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48381 PyObject *resultobj = 0;
48382 wxSizerItem *result = 0 ;
48383
48384 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48385 {
48386 PyThreadState* __tstate = wxPyBeginAllowThreads();
48387 result = (wxSizerItem *)new wxSizerItem();
48388 wxPyEndAllowThreads(__tstate);
48389 if (PyErr_Occurred()) SWIG_fail;
48390 }
48391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48392 return resultobj;
48393 fail:
48394 return NULL;
48395 }
48396
48397
48398 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48399 PyObject *resultobj = 0;
48400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48401 void *argp1 = 0 ;
48402 int res1 = 0 ;
48403 PyObject *swig_obj[1] ;
48404
48405 if (!args) SWIG_fail;
48406 swig_obj[0] = args;
48407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48408 if (!SWIG_IsOK(res1)) {
48409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48410 }
48411 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 delete arg1;
48415
48416 wxPyEndAllowThreads(__tstate);
48417 if (PyErr_Occurred()) SWIG_fail;
48418 }
48419 resultobj = SWIG_Py_Void();
48420 return resultobj;
48421 fail:
48422 return NULL;
48423 }
48424
48425
48426 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48427 PyObject *resultobj = 0;
48428 wxWindow *arg1 = (wxWindow *) 0 ;
48429 int arg2 ;
48430 int arg3 ;
48431 int arg4 ;
48432 PyObject *arg5 = (PyObject *) NULL ;
48433 wxSizerItem *result = 0 ;
48434 void *argp1 = 0 ;
48435 int res1 = 0 ;
48436 int val2 ;
48437 int ecode2 = 0 ;
48438 int val3 ;
48439 int ecode3 = 0 ;
48440 int val4 ;
48441 int ecode4 = 0 ;
48442 PyObject * obj0 = 0 ;
48443 PyObject * obj1 = 0 ;
48444 PyObject * obj2 = 0 ;
48445 PyObject * obj3 = 0 ;
48446 PyObject * obj4 = 0 ;
48447 char * kwnames[] = {
48448 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48449 };
48450
48451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48453 if (!SWIG_IsOK(res1)) {
48454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48455 }
48456 arg1 = reinterpret_cast< wxWindow * >(argp1);
48457 ecode2 = SWIG_AsVal_int(obj1, &val2);
48458 if (!SWIG_IsOK(ecode2)) {
48459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48460 }
48461 arg2 = static_cast< int >(val2);
48462 ecode3 = SWIG_AsVal_int(obj2, &val3);
48463 if (!SWIG_IsOK(ecode3)) {
48464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48465 }
48466 arg3 = static_cast< int >(val3);
48467 ecode4 = SWIG_AsVal_int(obj3, &val4);
48468 if (!SWIG_IsOK(ecode4)) {
48469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48470 }
48471 arg4 = static_cast< int >(val4);
48472 if (obj4) {
48473 arg5 = obj4;
48474 }
48475 {
48476 PyThreadState* __tstate = wxPyBeginAllowThreads();
48477 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48478 wxPyEndAllowThreads(__tstate);
48479 if (PyErr_Occurred()) SWIG_fail;
48480 }
48481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48489 PyObject *resultobj = 0;
48490 int arg1 ;
48491 int arg2 ;
48492 int arg3 ;
48493 int arg4 ;
48494 int arg5 ;
48495 PyObject *arg6 = (PyObject *) NULL ;
48496 wxSizerItem *result = 0 ;
48497 int val1 ;
48498 int ecode1 = 0 ;
48499 int val2 ;
48500 int ecode2 = 0 ;
48501 int val3 ;
48502 int ecode3 = 0 ;
48503 int val4 ;
48504 int ecode4 = 0 ;
48505 int val5 ;
48506 int ecode5 = 0 ;
48507 PyObject * obj0 = 0 ;
48508 PyObject * obj1 = 0 ;
48509 PyObject * obj2 = 0 ;
48510 PyObject * obj3 = 0 ;
48511 PyObject * obj4 = 0 ;
48512 PyObject * obj5 = 0 ;
48513 char * kwnames[] = {
48514 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48515 };
48516
48517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48518 ecode1 = SWIG_AsVal_int(obj0, &val1);
48519 if (!SWIG_IsOK(ecode1)) {
48520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48521 }
48522 arg1 = static_cast< int >(val1);
48523 ecode2 = SWIG_AsVal_int(obj1, &val2);
48524 if (!SWIG_IsOK(ecode2)) {
48525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48526 }
48527 arg2 = static_cast< int >(val2);
48528 ecode3 = SWIG_AsVal_int(obj2, &val3);
48529 if (!SWIG_IsOK(ecode3)) {
48530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48531 }
48532 arg3 = static_cast< int >(val3);
48533 ecode4 = SWIG_AsVal_int(obj3, &val4);
48534 if (!SWIG_IsOK(ecode4)) {
48535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48536 }
48537 arg4 = static_cast< int >(val4);
48538 ecode5 = SWIG_AsVal_int(obj4, &val5);
48539 if (!SWIG_IsOK(ecode5)) {
48540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48541 }
48542 arg5 = static_cast< int >(val5);
48543 if (obj5) {
48544 arg6 = obj5;
48545 }
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48560 PyObject *resultobj = 0;
48561 wxSizer *arg1 = (wxSizer *) 0 ;
48562 int arg2 ;
48563 int arg3 ;
48564 int arg4 ;
48565 PyObject *arg5 = (PyObject *) NULL ;
48566 wxSizerItem *result = 0 ;
48567 int res1 = 0 ;
48568 int val2 ;
48569 int ecode2 = 0 ;
48570 int val3 ;
48571 int ecode3 = 0 ;
48572 int val4 ;
48573 int ecode4 = 0 ;
48574 PyObject * obj0 = 0 ;
48575 PyObject * obj1 = 0 ;
48576 PyObject * obj2 = 0 ;
48577 PyObject * obj3 = 0 ;
48578 PyObject * obj4 = 0 ;
48579 char * kwnames[] = {
48580 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48581 };
48582
48583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48584 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48585 if (!SWIG_IsOK(res1)) {
48586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48587 }
48588 ecode2 = SWIG_AsVal_int(obj1, &val2);
48589 if (!SWIG_IsOK(ecode2)) {
48590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48591 }
48592 arg2 = static_cast< int >(val2);
48593 ecode3 = SWIG_AsVal_int(obj2, &val3);
48594 if (!SWIG_IsOK(ecode3)) {
48595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48596 }
48597 arg3 = static_cast< int >(val3);
48598 ecode4 = SWIG_AsVal_int(obj3, &val4);
48599 if (!SWIG_IsOK(ecode4)) {
48600 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48601 }
48602 arg4 = static_cast< int >(val4);
48603 if (obj4) {
48604 arg5 = obj4;
48605 }
48606 {
48607 PyThreadState* __tstate = wxPyBeginAllowThreads();
48608 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48609 wxPyEndAllowThreads(__tstate);
48610 if (PyErr_Occurred()) SWIG_fail;
48611 }
48612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48613 return resultobj;
48614 fail:
48615 return NULL;
48616 }
48617
48618
48619 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48620 PyObject *resultobj = 0;
48621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48622 void *argp1 = 0 ;
48623 int res1 = 0 ;
48624 PyObject *swig_obj[1] ;
48625
48626 if (!args) SWIG_fail;
48627 swig_obj[0] = args;
48628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48629 if (!SWIG_IsOK(res1)) {
48630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48631 }
48632 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48633 {
48634 PyThreadState* __tstate = wxPyBeginAllowThreads();
48635 (arg1)->DeleteWindows();
48636 wxPyEndAllowThreads(__tstate);
48637 if (PyErr_Occurred()) SWIG_fail;
48638 }
48639 resultobj = SWIG_Py_Void();
48640 return resultobj;
48641 fail:
48642 return NULL;
48643 }
48644
48645
48646 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48647 PyObject *resultobj = 0;
48648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48649 void *argp1 = 0 ;
48650 int res1 = 0 ;
48651 PyObject *swig_obj[1] ;
48652
48653 if (!args) SWIG_fail;
48654 swig_obj[0] = args;
48655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48656 if (!SWIG_IsOK(res1)) {
48657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48658 }
48659 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48660 {
48661 PyThreadState* __tstate = wxPyBeginAllowThreads();
48662 (arg1)->DetachSizer();
48663 wxPyEndAllowThreads(__tstate);
48664 if (PyErr_Occurred()) SWIG_fail;
48665 }
48666 resultobj = SWIG_Py_Void();
48667 return resultobj;
48668 fail:
48669 return NULL;
48670 }
48671
48672
48673 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48674 PyObject *resultobj = 0;
48675 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48676 wxSize result;
48677 void *argp1 = 0 ;
48678 int res1 = 0 ;
48679 PyObject *swig_obj[1] ;
48680
48681 if (!args) SWIG_fail;
48682 swig_obj[0] = args;
48683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48684 if (!SWIG_IsOK(res1)) {
48685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48686 }
48687 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48688 {
48689 PyThreadState* __tstate = wxPyBeginAllowThreads();
48690 result = (arg1)->GetSize();
48691 wxPyEndAllowThreads(__tstate);
48692 if (PyErr_Occurred()) SWIG_fail;
48693 }
48694 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48695 return resultobj;
48696 fail:
48697 return NULL;
48698 }
48699
48700
48701 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48702 PyObject *resultobj = 0;
48703 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48704 wxSize result;
48705 void *argp1 = 0 ;
48706 int res1 = 0 ;
48707 PyObject *swig_obj[1] ;
48708
48709 if (!args) SWIG_fail;
48710 swig_obj[0] = args;
48711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48712 if (!SWIG_IsOK(res1)) {
48713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48714 }
48715 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (arg1)->CalcMin();
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48723 return resultobj;
48724 fail:
48725 return NULL;
48726 }
48727
48728
48729 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48730 PyObject *resultobj = 0;
48731 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48732 wxPoint *arg2 = 0 ;
48733 wxSize *arg3 = 0 ;
48734 void *argp1 = 0 ;
48735 int res1 = 0 ;
48736 wxPoint temp2 ;
48737 wxSize temp3 ;
48738 PyObject * obj0 = 0 ;
48739 PyObject * obj1 = 0 ;
48740 PyObject * obj2 = 0 ;
48741 char * kwnames[] = {
48742 (char *) "self",(char *) "pos",(char *) "size", NULL
48743 };
48744
48745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48747 if (!SWIG_IsOK(res1)) {
48748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48749 }
48750 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48751 {
48752 arg2 = &temp2;
48753 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48754 }
48755 {
48756 arg3 = &temp3;
48757 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48758 }
48759 {
48760 PyThreadState* __tstate = wxPyBeginAllowThreads();
48761 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48762 wxPyEndAllowThreads(__tstate);
48763 if (PyErr_Occurred()) SWIG_fail;
48764 }
48765 resultobj = SWIG_Py_Void();
48766 return resultobj;
48767 fail:
48768 return NULL;
48769 }
48770
48771
48772 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48773 PyObject *resultobj = 0;
48774 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48775 wxSize result;
48776 void *argp1 = 0 ;
48777 int res1 = 0 ;
48778 PyObject *swig_obj[1] ;
48779
48780 if (!args) SWIG_fail;
48781 swig_obj[0] = args;
48782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48783 if (!SWIG_IsOK(res1)) {
48784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48785 }
48786 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48787 {
48788 PyThreadState* __tstate = wxPyBeginAllowThreads();
48789 result = (arg1)->GetMinSize();
48790 wxPyEndAllowThreads(__tstate);
48791 if (PyErr_Occurred()) SWIG_fail;
48792 }
48793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48794 return resultobj;
48795 fail:
48796 return NULL;
48797 }
48798
48799
48800 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48801 PyObject *resultobj = 0;
48802 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48803 wxSize result;
48804 void *argp1 = 0 ;
48805 int res1 = 0 ;
48806 PyObject *swig_obj[1] ;
48807
48808 if (!args) SWIG_fail;
48809 swig_obj[0] = args;
48810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48811 if (!SWIG_IsOK(res1)) {
48812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48813 }
48814 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48815 {
48816 PyThreadState* __tstate = wxPyBeginAllowThreads();
48817 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48818 wxPyEndAllowThreads(__tstate);
48819 if (PyErr_Occurred()) SWIG_fail;
48820 }
48821 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48822 return resultobj;
48823 fail:
48824 return NULL;
48825 }
48826
48827
48828 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48829 PyObject *resultobj = 0;
48830 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48831 int arg2 ;
48832 int arg3 ;
48833 void *argp1 = 0 ;
48834 int res1 = 0 ;
48835 int val2 ;
48836 int ecode2 = 0 ;
48837 int val3 ;
48838 int ecode3 = 0 ;
48839 PyObject * obj0 = 0 ;
48840 PyObject * obj1 = 0 ;
48841 PyObject * obj2 = 0 ;
48842 char * kwnames[] = {
48843 (char *) "self",(char *) "x",(char *) "y", NULL
48844 };
48845
48846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48848 if (!SWIG_IsOK(res1)) {
48849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48850 }
48851 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48852 ecode2 = SWIG_AsVal_int(obj1, &val2);
48853 if (!SWIG_IsOK(ecode2)) {
48854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48855 }
48856 arg2 = static_cast< int >(val2);
48857 ecode3 = SWIG_AsVal_int(obj2, &val3);
48858 if (!SWIG_IsOK(ecode3)) {
48859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48860 }
48861 arg3 = static_cast< int >(val3);
48862 {
48863 PyThreadState* __tstate = wxPyBeginAllowThreads();
48864 (arg1)->SetInitSize(arg2,arg3);
48865 wxPyEndAllowThreads(__tstate);
48866 if (PyErr_Occurred()) SWIG_fail;
48867 }
48868 resultobj = SWIG_Py_Void();
48869 return resultobj;
48870 fail:
48871 return NULL;
48872 }
48873
48874
48875 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48876 PyObject *resultobj = 0;
48877 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48878 int arg2 ;
48879 int arg3 ;
48880 void *argp1 = 0 ;
48881 int res1 = 0 ;
48882 int val2 ;
48883 int ecode2 = 0 ;
48884 int val3 ;
48885 int ecode3 = 0 ;
48886 PyObject * obj0 = 0 ;
48887 PyObject * obj1 = 0 ;
48888 PyObject * obj2 = 0 ;
48889 char * kwnames[] = {
48890 (char *) "self",(char *) "width",(char *) "height", NULL
48891 };
48892
48893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48895 if (!SWIG_IsOK(res1)) {
48896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48897 }
48898 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48899 ecode2 = SWIG_AsVal_int(obj1, &val2);
48900 if (!SWIG_IsOK(ecode2)) {
48901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48902 }
48903 arg2 = static_cast< int >(val2);
48904 ecode3 = SWIG_AsVal_int(obj2, &val3);
48905 if (!SWIG_IsOK(ecode3)) {
48906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48907 }
48908 arg3 = static_cast< int >(val3);
48909 {
48910 PyThreadState* __tstate = wxPyBeginAllowThreads();
48911 (arg1)->SetRatio(arg2,arg3);
48912 wxPyEndAllowThreads(__tstate);
48913 if (PyErr_Occurred()) SWIG_fail;
48914 }
48915 resultobj = SWIG_Py_Void();
48916 return resultobj;
48917 fail:
48918 return NULL;
48919 }
48920
48921
48922 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48923 PyObject *resultobj = 0;
48924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48925 wxSize *arg2 = 0 ;
48926 void *argp1 = 0 ;
48927 int res1 = 0 ;
48928 wxSize temp2 ;
48929 PyObject * obj0 = 0 ;
48930 PyObject * obj1 = 0 ;
48931 char * kwnames[] = {
48932 (char *) "self",(char *) "size", NULL
48933 };
48934
48935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48939 }
48940 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48941 {
48942 arg2 = &temp2;
48943 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48944 }
48945 {
48946 PyThreadState* __tstate = wxPyBeginAllowThreads();
48947 (arg1)->SetRatio((wxSize const &)*arg2);
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_Py_Void();
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48959 PyObject *resultobj = 0;
48960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48961 float arg2 ;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 float val2 ;
48965 int ecode2 = 0 ;
48966 PyObject * obj0 = 0 ;
48967 PyObject * obj1 = 0 ;
48968 char * kwnames[] = {
48969 (char *) "self",(char *) "ratio", NULL
48970 };
48971
48972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48974 if (!SWIG_IsOK(res1)) {
48975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48976 }
48977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48978 ecode2 = SWIG_AsVal_float(obj1, &val2);
48979 if (!SWIG_IsOK(ecode2)) {
48980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48981 }
48982 arg2 = static_cast< float >(val2);
48983 {
48984 PyThreadState* __tstate = wxPyBeginAllowThreads();
48985 (arg1)->SetRatio(arg2);
48986 wxPyEndAllowThreads(__tstate);
48987 if (PyErr_Occurred()) SWIG_fail;
48988 }
48989 resultobj = SWIG_Py_Void();
48990 return resultobj;
48991 fail:
48992 return NULL;
48993 }
48994
48995
48996 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48997 PyObject *resultobj = 0;
48998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48999 float result;
49000 void *argp1 = 0 ;
49001 int res1 = 0 ;
49002 PyObject *swig_obj[1] ;
49003
49004 if (!args) SWIG_fail;
49005 swig_obj[0] = args;
49006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49007 if (!SWIG_IsOK(res1)) {
49008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49009 }
49010 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49011 {
49012 PyThreadState* __tstate = wxPyBeginAllowThreads();
49013 result = (float)(arg1)->GetRatio();
49014 wxPyEndAllowThreads(__tstate);
49015 if (PyErr_Occurred()) SWIG_fail;
49016 }
49017 resultobj = SWIG_From_float(static_cast< float >(result));
49018 return resultobj;
49019 fail:
49020 return NULL;
49021 }
49022
49023
49024 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49025 PyObject *resultobj = 0;
49026 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49027 wxRect result;
49028 void *argp1 = 0 ;
49029 int res1 = 0 ;
49030 PyObject *swig_obj[1] ;
49031
49032 if (!args) SWIG_fail;
49033 swig_obj[0] = args;
49034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49035 if (!SWIG_IsOK(res1)) {
49036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49037 }
49038 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49039 {
49040 PyThreadState* __tstate = wxPyBeginAllowThreads();
49041 result = (arg1)->GetRect();
49042 wxPyEndAllowThreads(__tstate);
49043 if (PyErr_Occurred()) SWIG_fail;
49044 }
49045 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49046 return resultobj;
49047 fail:
49048 return NULL;
49049 }
49050
49051
49052 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49053 PyObject *resultobj = 0;
49054 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49055 bool result;
49056 void *argp1 = 0 ;
49057 int res1 = 0 ;
49058 PyObject *swig_obj[1] ;
49059
49060 if (!args) SWIG_fail;
49061 swig_obj[0] = args;
49062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49063 if (!SWIG_IsOK(res1)) {
49064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49065 }
49066 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49067 {
49068 PyThreadState* __tstate = wxPyBeginAllowThreads();
49069 result = (bool)(arg1)->IsWindow();
49070 wxPyEndAllowThreads(__tstate);
49071 if (PyErr_Occurred()) SWIG_fail;
49072 }
49073 {
49074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49075 }
49076 return resultobj;
49077 fail:
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49083 PyObject *resultobj = 0;
49084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49085 bool result;
49086 void *argp1 = 0 ;
49087 int res1 = 0 ;
49088 PyObject *swig_obj[1] ;
49089
49090 if (!args) SWIG_fail;
49091 swig_obj[0] = args;
49092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49093 if (!SWIG_IsOK(res1)) {
49094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49095 }
49096 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49097 {
49098 PyThreadState* __tstate = wxPyBeginAllowThreads();
49099 result = (bool)(arg1)->IsSizer();
49100 wxPyEndAllowThreads(__tstate);
49101 if (PyErr_Occurred()) SWIG_fail;
49102 }
49103 {
49104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49105 }
49106 return resultobj;
49107 fail:
49108 return NULL;
49109 }
49110
49111
49112 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49113 PyObject *resultobj = 0;
49114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49115 bool result;
49116 void *argp1 = 0 ;
49117 int res1 = 0 ;
49118 PyObject *swig_obj[1] ;
49119
49120 if (!args) SWIG_fail;
49121 swig_obj[0] = args;
49122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49123 if (!SWIG_IsOK(res1)) {
49124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49125 }
49126 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49127 {
49128 PyThreadState* __tstate = wxPyBeginAllowThreads();
49129 result = (bool)(arg1)->IsSpacer();
49130 wxPyEndAllowThreads(__tstate);
49131 if (PyErr_Occurred()) SWIG_fail;
49132 }
49133 {
49134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49135 }
49136 return resultobj;
49137 fail:
49138 return NULL;
49139 }
49140
49141
49142 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49143 PyObject *resultobj = 0;
49144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49145 int arg2 ;
49146 void *argp1 = 0 ;
49147 int res1 = 0 ;
49148 int val2 ;
49149 int ecode2 = 0 ;
49150 PyObject * obj0 = 0 ;
49151 PyObject * obj1 = 0 ;
49152 char * kwnames[] = {
49153 (char *) "self",(char *) "proportion", NULL
49154 };
49155
49156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49158 if (!SWIG_IsOK(res1)) {
49159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49160 }
49161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49162 ecode2 = SWIG_AsVal_int(obj1, &val2);
49163 if (!SWIG_IsOK(ecode2)) {
49164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49165 }
49166 arg2 = static_cast< int >(val2);
49167 {
49168 PyThreadState* __tstate = wxPyBeginAllowThreads();
49169 (arg1)->SetProportion(arg2);
49170 wxPyEndAllowThreads(__tstate);
49171 if (PyErr_Occurred()) SWIG_fail;
49172 }
49173 resultobj = SWIG_Py_Void();
49174 return resultobj;
49175 fail:
49176 return NULL;
49177 }
49178
49179
49180 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49181 PyObject *resultobj = 0;
49182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49183 int result;
49184 void *argp1 = 0 ;
49185 int res1 = 0 ;
49186 PyObject *swig_obj[1] ;
49187
49188 if (!args) SWIG_fail;
49189 swig_obj[0] = args;
49190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49191 if (!SWIG_IsOK(res1)) {
49192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49193 }
49194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49195 {
49196 PyThreadState* __tstate = wxPyBeginAllowThreads();
49197 result = (int)(arg1)->GetProportion();
49198 wxPyEndAllowThreads(__tstate);
49199 if (PyErr_Occurred()) SWIG_fail;
49200 }
49201 resultobj = SWIG_From_int(static_cast< int >(result));
49202 return resultobj;
49203 fail:
49204 return NULL;
49205 }
49206
49207
49208 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49209 PyObject *resultobj = 0;
49210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49211 int arg2 ;
49212 void *argp1 = 0 ;
49213 int res1 = 0 ;
49214 int val2 ;
49215 int ecode2 = 0 ;
49216 PyObject * obj0 = 0 ;
49217 PyObject * obj1 = 0 ;
49218 char * kwnames[] = {
49219 (char *) "self",(char *) "flag", NULL
49220 };
49221
49222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49224 if (!SWIG_IsOK(res1)) {
49225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49226 }
49227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49228 ecode2 = SWIG_AsVal_int(obj1, &val2);
49229 if (!SWIG_IsOK(ecode2)) {
49230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49231 }
49232 arg2 = static_cast< int >(val2);
49233 {
49234 PyThreadState* __tstate = wxPyBeginAllowThreads();
49235 (arg1)->SetFlag(arg2);
49236 wxPyEndAllowThreads(__tstate);
49237 if (PyErr_Occurred()) SWIG_fail;
49238 }
49239 resultobj = SWIG_Py_Void();
49240 return resultobj;
49241 fail:
49242 return NULL;
49243 }
49244
49245
49246 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49247 PyObject *resultobj = 0;
49248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49249 int result;
49250 void *argp1 = 0 ;
49251 int res1 = 0 ;
49252 PyObject *swig_obj[1] ;
49253
49254 if (!args) SWIG_fail;
49255 swig_obj[0] = args;
49256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49257 if (!SWIG_IsOK(res1)) {
49258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49259 }
49260 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49261 {
49262 PyThreadState* __tstate = wxPyBeginAllowThreads();
49263 result = (int)(arg1)->GetFlag();
49264 wxPyEndAllowThreads(__tstate);
49265 if (PyErr_Occurred()) SWIG_fail;
49266 }
49267 resultobj = SWIG_From_int(static_cast< int >(result));
49268 return resultobj;
49269 fail:
49270 return NULL;
49271 }
49272
49273
49274 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49275 PyObject *resultobj = 0;
49276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49277 int arg2 ;
49278 void *argp1 = 0 ;
49279 int res1 = 0 ;
49280 int val2 ;
49281 int ecode2 = 0 ;
49282 PyObject * obj0 = 0 ;
49283 PyObject * obj1 = 0 ;
49284 char * kwnames[] = {
49285 (char *) "self",(char *) "border", NULL
49286 };
49287
49288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49290 if (!SWIG_IsOK(res1)) {
49291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49292 }
49293 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49294 ecode2 = SWIG_AsVal_int(obj1, &val2);
49295 if (!SWIG_IsOK(ecode2)) {
49296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49297 }
49298 arg2 = static_cast< int >(val2);
49299 {
49300 PyThreadState* __tstate = wxPyBeginAllowThreads();
49301 (arg1)->SetBorder(arg2);
49302 wxPyEndAllowThreads(__tstate);
49303 if (PyErr_Occurred()) SWIG_fail;
49304 }
49305 resultobj = SWIG_Py_Void();
49306 return resultobj;
49307 fail:
49308 return NULL;
49309 }
49310
49311
49312 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49313 PyObject *resultobj = 0;
49314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49315 int result;
49316 void *argp1 = 0 ;
49317 int res1 = 0 ;
49318 PyObject *swig_obj[1] ;
49319
49320 if (!args) SWIG_fail;
49321 swig_obj[0] = args;
49322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49323 if (!SWIG_IsOK(res1)) {
49324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49325 }
49326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 result = (int)(arg1)->GetBorder();
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_From_int(static_cast< int >(result));
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49341 PyObject *resultobj = 0;
49342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49343 wxWindow *result = 0 ;
49344 void *argp1 = 0 ;
49345 int res1 = 0 ;
49346 PyObject *swig_obj[1] ;
49347
49348 if (!args) SWIG_fail;
49349 swig_obj[0] = args;
49350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49351 if (!SWIG_IsOK(res1)) {
49352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49353 }
49354 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49355 {
49356 PyThreadState* __tstate = wxPyBeginAllowThreads();
49357 result = (wxWindow *)(arg1)->GetWindow();
49358 wxPyEndAllowThreads(__tstate);
49359 if (PyErr_Occurred()) SWIG_fail;
49360 }
49361 {
49362 resultobj = wxPyMake_wxObject(result, 0);
49363 }
49364 return resultobj;
49365 fail:
49366 return NULL;
49367 }
49368
49369
49370 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49371 PyObject *resultobj = 0;
49372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49373 wxWindow *arg2 = (wxWindow *) 0 ;
49374 void *argp1 = 0 ;
49375 int res1 = 0 ;
49376 void *argp2 = 0 ;
49377 int res2 = 0 ;
49378 PyObject * obj0 = 0 ;
49379 PyObject * obj1 = 0 ;
49380 char * kwnames[] = {
49381 (char *) "self",(char *) "window", NULL
49382 };
49383
49384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49386 if (!SWIG_IsOK(res1)) {
49387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49388 }
49389 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49391 if (!SWIG_IsOK(res2)) {
49392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49393 }
49394 arg2 = reinterpret_cast< wxWindow * >(argp2);
49395 {
49396 PyThreadState* __tstate = wxPyBeginAllowThreads();
49397 (arg1)->SetWindow(arg2);
49398 wxPyEndAllowThreads(__tstate);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 resultobj = SWIG_Py_Void();
49402 return resultobj;
49403 fail:
49404 return NULL;
49405 }
49406
49407
49408 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49409 PyObject *resultobj = 0;
49410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49411 wxSizer *result = 0 ;
49412 void *argp1 = 0 ;
49413 int res1 = 0 ;
49414 PyObject *swig_obj[1] ;
49415
49416 if (!args) SWIG_fail;
49417 swig_obj[0] = args;
49418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49419 if (!SWIG_IsOK(res1)) {
49420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49421 }
49422 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49423 {
49424 PyThreadState* __tstate = wxPyBeginAllowThreads();
49425 result = (wxSizer *)(arg1)->GetSizer();
49426 wxPyEndAllowThreads(__tstate);
49427 if (PyErr_Occurred()) SWIG_fail;
49428 }
49429 {
49430 resultobj = wxPyMake_wxObject(result, (bool)0);
49431 }
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49439 PyObject *resultobj = 0;
49440 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49441 wxSizer *arg2 = (wxSizer *) 0 ;
49442 void *argp1 = 0 ;
49443 int res1 = 0 ;
49444 int res2 = 0 ;
49445 PyObject * obj0 = 0 ;
49446 PyObject * obj1 = 0 ;
49447 char * kwnames[] = {
49448 (char *) "self",(char *) "sizer", NULL
49449 };
49450
49451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49453 if (!SWIG_IsOK(res1)) {
49454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49455 }
49456 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49457 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49458 if (!SWIG_IsOK(res2)) {
49459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49460 }
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 (arg1)->SetSizer(arg2);
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_Py_Void();
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49475 PyObject *resultobj = 0;
49476 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49477 wxSize result;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 PyObject *swig_obj[1] ;
49481
49482 if (!args) SWIG_fail;
49483 swig_obj[0] = args;
49484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49485 if (!SWIG_IsOK(res1)) {
49486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49487 }
49488 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49489 {
49490 PyThreadState* __tstate = wxPyBeginAllowThreads();
49491 result = (arg1)->GetSpacer();
49492 wxPyEndAllowThreads(__tstate);
49493 if (PyErr_Occurred()) SWIG_fail;
49494 }
49495 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49496 return resultobj;
49497 fail:
49498 return NULL;
49499 }
49500
49501
49502 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49503 PyObject *resultobj = 0;
49504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49505 wxSize *arg2 = 0 ;
49506 void *argp1 = 0 ;
49507 int res1 = 0 ;
49508 wxSize temp2 ;
49509 PyObject * obj0 = 0 ;
49510 PyObject * obj1 = 0 ;
49511 char * kwnames[] = {
49512 (char *) "self",(char *) "size", NULL
49513 };
49514
49515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49517 if (!SWIG_IsOK(res1)) {
49518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49519 }
49520 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49521 {
49522 arg2 = &temp2;
49523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49524 }
49525 {
49526 PyThreadState* __tstate = wxPyBeginAllowThreads();
49527 (arg1)->SetSpacer((wxSize const &)*arg2);
49528 wxPyEndAllowThreads(__tstate);
49529 if (PyErr_Occurred()) SWIG_fail;
49530 }
49531 resultobj = SWIG_Py_Void();
49532 return resultobj;
49533 fail:
49534 return NULL;
49535 }
49536
49537
49538 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49539 PyObject *resultobj = 0;
49540 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49541 bool arg2 ;
49542 void *argp1 = 0 ;
49543 int res1 = 0 ;
49544 bool val2 ;
49545 int ecode2 = 0 ;
49546 PyObject * obj0 = 0 ;
49547 PyObject * obj1 = 0 ;
49548 char * kwnames[] = {
49549 (char *) "self",(char *) "show", NULL
49550 };
49551
49552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49554 if (!SWIG_IsOK(res1)) {
49555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49556 }
49557 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49559 if (!SWIG_IsOK(ecode2)) {
49560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49561 }
49562 arg2 = static_cast< bool >(val2);
49563 {
49564 PyThreadState* __tstate = wxPyBeginAllowThreads();
49565 (arg1)->Show(arg2);
49566 wxPyEndAllowThreads(__tstate);
49567 if (PyErr_Occurred()) SWIG_fail;
49568 }
49569 resultobj = SWIG_Py_Void();
49570 return resultobj;
49571 fail:
49572 return NULL;
49573 }
49574
49575
49576 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49577 PyObject *resultobj = 0;
49578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49579 bool result;
49580 void *argp1 = 0 ;
49581 int res1 = 0 ;
49582 PyObject *swig_obj[1] ;
49583
49584 if (!args) SWIG_fail;
49585 swig_obj[0] = args;
49586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49587 if (!SWIG_IsOK(res1)) {
49588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49589 }
49590 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49591 {
49592 PyThreadState* __tstate = wxPyBeginAllowThreads();
49593 result = (bool)(arg1)->IsShown();
49594 wxPyEndAllowThreads(__tstate);
49595 if (PyErr_Occurred()) SWIG_fail;
49596 }
49597 {
49598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49599 }
49600 return resultobj;
49601 fail:
49602 return NULL;
49603 }
49604
49605
49606 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49607 PyObject *resultobj = 0;
49608 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49609 wxPoint result;
49610 void *argp1 = 0 ;
49611 int res1 = 0 ;
49612 PyObject *swig_obj[1] ;
49613
49614 if (!args) SWIG_fail;
49615 swig_obj[0] = args;
49616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49617 if (!SWIG_IsOK(res1)) {
49618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49619 }
49620 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49621 {
49622 PyThreadState* __tstate = wxPyBeginAllowThreads();
49623 result = (arg1)->GetPosition();
49624 wxPyEndAllowThreads(__tstate);
49625 if (PyErr_Occurred()) SWIG_fail;
49626 }
49627 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49628 return resultobj;
49629 fail:
49630 return NULL;
49631 }
49632
49633
49634 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49635 PyObject *resultobj = 0;
49636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49637 PyObject *result = 0 ;
49638 void *argp1 = 0 ;
49639 int res1 = 0 ;
49640 PyObject *swig_obj[1] ;
49641
49642 if (!args) SWIG_fail;
49643 swig_obj[0] = args;
49644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49645 if (!SWIG_IsOK(res1)) {
49646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49647 }
49648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49649 {
49650 PyThreadState* __tstate = wxPyBeginAllowThreads();
49651 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49652 wxPyEndAllowThreads(__tstate);
49653 if (PyErr_Occurred()) SWIG_fail;
49654 }
49655 resultobj = result;
49656 return resultobj;
49657 fail:
49658 return NULL;
49659 }
49660
49661
49662 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49663 PyObject *resultobj = 0;
49664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49665 PyObject *arg2 = (PyObject *) 0 ;
49666 void *argp1 = 0 ;
49667 int res1 = 0 ;
49668 PyObject * obj0 = 0 ;
49669 PyObject * obj1 = 0 ;
49670 char * kwnames[] = {
49671 (char *) "self",(char *) "userData", NULL
49672 };
49673
49674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49676 if (!SWIG_IsOK(res1)) {
49677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49678 }
49679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49680 arg2 = obj1;
49681 {
49682 PyThreadState* __tstate = wxPyBeginAllowThreads();
49683 wxSizerItem_SetUserData(arg1,arg2);
49684 wxPyEndAllowThreads(__tstate);
49685 if (PyErr_Occurred()) SWIG_fail;
49686 }
49687 resultobj = SWIG_Py_Void();
49688 return resultobj;
49689 fail:
49690 return NULL;
49691 }
49692
49693
49694 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49695 PyObject *obj;
49696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49697 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49698 return SWIG_Py_Void();
49699 }
49700
49701 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49702 return SWIG_Python_InitShadowInstance(args);
49703 }
49704
49705 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49706 PyObject *resultobj = 0;
49707 wxSizer *arg1 = (wxSizer *) 0 ;
49708 void *argp1 = 0 ;
49709 int res1 = 0 ;
49710 PyObject *swig_obj[1] ;
49711
49712 if (!args) SWIG_fail;
49713 swig_obj[0] = args;
49714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49715 if (!SWIG_IsOK(res1)) {
49716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49717 }
49718 arg1 = reinterpret_cast< wxSizer * >(argp1);
49719 {
49720 PyThreadState* __tstate = wxPyBeginAllowThreads();
49721 delete arg1;
49722
49723 wxPyEndAllowThreads(__tstate);
49724 if (PyErr_Occurred()) SWIG_fail;
49725 }
49726 resultobj = SWIG_Py_Void();
49727 return resultobj;
49728 fail:
49729 return NULL;
49730 }
49731
49732
49733 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49734 PyObject *resultobj = 0;
49735 wxSizer *arg1 = (wxSizer *) 0 ;
49736 PyObject *arg2 = (PyObject *) 0 ;
49737 void *argp1 = 0 ;
49738 int res1 = 0 ;
49739 PyObject * obj0 = 0 ;
49740 PyObject * obj1 = 0 ;
49741 char * kwnames[] = {
49742 (char *) "self",(char *) "_self", NULL
49743 };
49744
49745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49749 }
49750 arg1 = reinterpret_cast< wxSizer * >(argp1);
49751 arg2 = obj1;
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 wxSizer__setOORInfo(arg1,arg2);
49755 wxPyEndAllowThreads(__tstate);
49756 if (PyErr_Occurred()) SWIG_fail;
49757 }
49758 resultobj = SWIG_Py_Void();
49759 return resultobj;
49760 fail:
49761 return NULL;
49762 }
49763
49764
49765 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49766 PyObject *resultobj = 0;
49767 wxSizer *arg1 = (wxSizer *) 0 ;
49768 PyObject *arg2 = (PyObject *) 0 ;
49769 int arg3 = (int) 0 ;
49770 int arg4 = (int) 0 ;
49771 int arg5 = (int) 0 ;
49772 PyObject *arg6 = (PyObject *) NULL ;
49773 wxSizerItem *result = 0 ;
49774 void *argp1 = 0 ;
49775 int res1 = 0 ;
49776 int val3 ;
49777 int ecode3 = 0 ;
49778 int val4 ;
49779 int ecode4 = 0 ;
49780 int val5 ;
49781 int ecode5 = 0 ;
49782 PyObject * obj0 = 0 ;
49783 PyObject * obj1 = 0 ;
49784 PyObject * obj2 = 0 ;
49785 PyObject * obj3 = 0 ;
49786 PyObject * obj4 = 0 ;
49787 PyObject * obj5 = 0 ;
49788 char * kwnames[] = {
49789 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49790 };
49791
49792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49794 if (!SWIG_IsOK(res1)) {
49795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49796 }
49797 arg1 = reinterpret_cast< wxSizer * >(argp1);
49798 arg2 = obj1;
49799 if (obj2) {
49800 ecode3 = SWIG_AsVal_int(obj2, &val3);
49801 if (!SWIG_IsOK(ecode3)) {
49802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49803 }
49804 arg3 = static_cast< int >(val3);
49805 }
49806 if (obj3) {
49807 ecode4 = SWIG_AsVal_int(obj3, &val4);
49808 if (!SWIG_IsOK(ecode4)) {
49809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49810 }
49811 arg4 = static_cast< int >(val4);
49812 }
49813 if (obj4) {
49814 ecode5 = SWIG_AsVal_int(obj4, &val5);
49815 if (!SWIG_IsOK(ecode5)) {
49816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49817 }
49818 arg5 = static_cast< int >(val5);
49819 }
49820 if (obj5) {
49821 arg6 = obj5;
49822 }
49823 {
49824 PyThreadState* __tstate = wxPyBeginAllowThreads();
49825 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49826 wxPyEndAllowThreads(__tstate);
49827 if (PyErr_Occurred()) SWIG_fail;
49828 }
49829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49830 return resultobj;
49831 fail:
49832 return NULL;
49833 }
49834
49835
49836 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49837 PyObject *resultobj = 0;
49838 wxSizer *arg1 = (wxSizer *) 0 ;
49839 int arg2 ;
49840 PyObject *arg3 = (PyObject *) 0 ;
49841 int arg4 = (int) 0 ;
49842 int arg5 = (int) 0 ;
49843 int arg6 = (int) 0 ;
49844 PyObject *arg7 = (PyObject *) NULL ;
49845 wxSizerItem *result = 0 ;
49846 void *argp1 = 0 ;
49847 int res1 = 0 ;
49848 int val2 ;
49849 int ecode2 = 0 ;
49850 int val4 ;
49851 int ecode4 = 0 ;
49852 int val5 ;
49853 int ecode5 = 0 ;
49854 int val6 ;
49855 int ecode6 = 0 ;
49856 PyObject * obj0 = 0 ;
49857 PyObject * obj1 = 0 ;
49858 PyObject * obj2 = 0 ;
49859 PyObject * obj3 = 0 ;
49860 PyObject * obj4 = 0 ;
49861 PyObject * obj5 = 0 ;
49862 PyObject * obj6 = 0 ;
49863 char * kwnames[] = {
49864 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49865 };
49866
49867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49869 if (!SWIG_IsOK(res1)) {
49870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49871 }
49872 arg1 = reinterpret_cast< wxSizer * >(argp1);
49873 ecode2 = SWIG_AsVal_int(obj1, &val2);
49874 if (!SWIG_IsOK(ecode2)) {
49875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49876 }
49877 arg2 = static_cast< int >(val2);
49878 arg3 = obj2;
49879 if (obj3) {
49880 ecode4 = SWIG_AsVal_int(obj3, &val4);
49881 if (!SWIG_IsOK(ecode4)) {
49882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49883 }
49884 arg4 = static_cast< int >(val4);
49885 }
49886 if (obj4) {
49887 ecode5 = SWIG_AsVal_int(obj4, &val5);
49888 if (!SWIG_IsOK(ecode5)) {
49889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49890 }
49891 arg5 = static_cast< int >(val5);
49892 }
49893 if (obj5) {
49894 ecode6 = SWIG_AsVal_int(obj5, &val6);
49895 if (!SWIG_IsOK(ecode6)) {
49896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49897 }
49898 arg6 = static_cast< int >(val6);
49899 }
49900 if (obj6) {
49901 arg7 = obj6;
49902 }
49903 {
49904 PyThreadState* __tstate = wxPyBeginAllowThreads();
49905 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49906 wxPyEndAllowThreads(__tstate);
49907 if (PyErr_Occurred()) SWIG_fail;
49908 }
49909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49910 return resultobj;
49911 fail:
49912 return NULL;
49913 }
49914
49915
49916 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49917 PyObject *resultobj = 0;
49918 wxSizer *arg1 = (wxSizer *) 0 ;
49919 PyObject *arg2 = (PyObject *) 0 ;
49920 int arg3 = (int) 0 ;
49921 int arg4 = (int) 0 ;
49922 int arg5 = (int) 0 ;
49923 PyObject *arg6 = (PyObject *) NULL ;
49924 wxSizerItem *result = 0 ;
49925 void *argp1 = 0 ;
49926 int res1 = 0 ;
49927 int val3 ;
49928 int ecode3 = 0 ;
49929 int val4 ;
49930 int ecode4 = 0 ;
49931 int val5 ;
49932 int ecode5 = 0 ;
49933 PyObject * obj0 = 0 ;
49934 PyObject * obj1 = 0 ;
49935 PyObject * obj2 = 0 ;
49936 PyObject * obj3 = 0 ;
49937 PyObject * obj4 = 0 ;
49938 PyObject * obj5 = 0 ;
49939 char * kwnames[] = {
49940 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49941 };
49942
49943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49945 if (!SWIG_IsOK(res1)) {
49946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49947 }
49948 arg1 = reinterpret_cast< wxSizer * >(argp1);
49949 arg2 = obj1;
49950 if (obj2) {
49951 ecode3 = SWIG_AsVal_int(obj2, &val3);
49952 if (!SWIG_IsOK(ecode3)) {
49953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49954 }
49955 arg3 = static_cast< int >(val3);
49956 }
49957 if (obj3) {
49958 ecode4 = SWIG_AsVal_int(obj3, &val4);
49959 if (!SWIG_IsOK(ecode4)) {
49960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49961 }
49962 arg4 = static_cast< int >(val4);
49963 }
49964 if (obj4) {
49965 ecode5 = SWIG_AsVal_int(obj4, &val5);
49966 if (!SWIG_IsOK(ecode5)) {
49967 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49968 }
49969 arg5 = static_cast< int >(val5);
49970 }
49971 if (obj5) {
49972 arg6 = obj5;
49973 }
49974 {
49975 PyThreadState* __tstate = wxPyBeginAllowThreads();
49976 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49977 wxPyEndAllowThreads(__tstate);
49978 if (PyErr_Occurred()) SWIG_fail;
49979 }
49980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49981 return resultobj;
49982 fail:
49983 return NULL;
49984 }
49985
49986
49987 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49988 PyObject *resultobj = 0;
49989 wxSizer *arg1 = (wxSizer *) 0 ;
49990 PyObject *arg2 = (PyObject *) 0 ;
49991 bool result;
49992 void *argp1 = 0 ;
49993 int res1 = 0 ;
49994 PyObject * obj0 = 0 ;
49995 PyObject * obj1 = 0 ;
49996 char * kwnames[] = {
49997 (char *) "self",(char *) "item", NULL
49998 };
49999
50000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50002 if (!SWIG_IsOK(res1)) {
50003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50004 }
50005 arg1 = reinterpret_cast< wxSizer * >(argp1);
50006 arg2 = obj1;
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (bool)wxSizer_Remove(arg1,arg2);
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 {
50014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50015 }
50016 return resultobj;
50017 fail:
50018 return NULL;
50019 }
50020
50021
50022 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50023 PyObject *resultobj = 0;
50024 wxSizer *arg1 = (wxSizer *) 0 ;
50025 PyObject *arg2 = (PyObject *) 0 ;
50026 bool result;
50027 void *argp1 = 0 ;
50028 int res1 = 0 ;
50029 PyObject * obj0 = 0 ;
50030 PyObject * obj1 = 0 ;
50031 char * kwnames[] = {
50032 (char *) "self",(char *) "item", NULL
50033 };
50034
50035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50037 if (!SWIG_IsOK(res1)) {
50038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50039 }
50040 arg1 = reinterpret_cast< wxSizer * >(argp1);
50041 arg2 = obj1;
50042 {
50043 PyThreadState* __tstate = wxPyBeginAllowThreads();
50044 result = (bool)wxSizer_Detach(arg1,arg2);
50045 wxPyEndAllowThreads(__tstate);
50046 if (PyErr_Occurred()) SWIG_fail;
50047 }
50048 {
50049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50050 }
50051 return resultobj;
50052 fail:
50053 return NULL;
50054 }
50055
50056
50057 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50058 PyObject *resultobj = 0;
50059 wxSizer *arg1 = (wxSizer *) 0 ;
50060 PyObject *arg2 = (PyObject *) 0 ;
50061 wxSizerItem *result = 0 ;
50062 void *argp1 = 0 ;
50063 int res1 = 0 ;
50064 PyObject * obj0 = 0 ;
50065 PyObject * obj1 = 0 ;
50066 char * kwnames[] = {
50067 (char *) "self",(char *) "item", NULL
50068 };
50069
50070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50072 if (!SWIG_IsOK(res1)) {
50073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50074 }
50075 arg1 = reinterpret_cast< wxSizer * >(argp1);
50076 arg2 = obj1;
50077 {
50078 PyThreadState* __tstate = wxPyBeginAllowThreads();
50079 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50080 wxPyEndAllowThreads(__tstate);
50081 if (PyErr_Occurred()) SWIG_fail;
50082 }
50083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50084 return resultobj;
50085 fail:
50086 return NULL;
50087 }
50088
50089
50090 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50091 PyObject *resultobj = 0;
50092 wxSizer *arg1 = (wxSizer *) 0 ;
50093 PyObject *arg2 = (PyObject *) 0 ;
50094 wxSize *arg3 = 0 ;
50095 void *argp1 = 0 ;
50096 int res1 = 0 ;
50097 wxSize temp3 ;
50098 PyObject * obj0 = 0 ;
50099 PyObject * obj1 = 0 ;
50100 PyObject * obj2 = 0 ;
50101 char * kwnames[] = {
50102 (char *) "self",(char *) "item",(char *) "size", NULL
50103 };
50104
50105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50107 if (!SWIG_IsOK(res1)) {
50108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50109 }
50110 arg1 = reinterpret_cast< wxSizer * >(argp1);
50111 arg2 = obj1;
50112 {
50113 arg3 = &temp3;
50114 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50115 }
50116 {
50117 PyThreadState* __tstate = wxPyBeginAllowThreads();
50118 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50119 wxPyEndAllowThreads(__tstate);
50120 if (PyErr_Occurred()) SWIG_fail;
50121 }
50122 resultobj = SWIG_Py_Void();
50123 return resultobj;
50124 fail:
50125 return NULL;
50126 }
50127
50128
50129 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50130 PyObject *resultobj = 0;
50131 wxSizer *arg1 = (wxSizer *) 0 ;
50132 wxWindow *arg2 = (wxWindow *) 0 ;
50133 wxWindow *arg3 = (wxWindow *) 0 ;
50134 bool arg4 = (bool) false ;
50135 bool result;
50136 void *argp1 = 0 ;
50137 int res1 = 0 ;
50138 void *argp2 = 0 ;
50139 int res2 = 0 ;
50140 void *argp3 = 0 ;
50141 int res3 = 0 ;
50142 bool val4 ;
50143 int ecode4 = 0 ;
50144 PyObject * obj0 = 0 ;
50145 PyObject * obj1 = 0 ;
50146 PyObject * obj2 = 0 ;
50147 PyObject * obj3 = 0 ;
50148 char * kwnames[] = {
50149 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50150 };
50151
50152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50154 if (!SWIG_IsOK(res1)) {
50155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50156 }
50157 arg1 = reinterpret_cast< wxSizer * >(argp1);
50158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50159 if (!SWIG_IsOK(res2)) {
50160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50161 }
50162 arg2 = reinterpret_cast< wxWindow * >(argp2);
50163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50164 if (!SWIG_IsOK(res3)) {
50165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50166 }
50167 arg3 = reinterpret_cast< wxWindow * >(argp3);
50168 if (obj3) {
50169 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50170 if (!SWIG_IsOK(ecode4)) {
50171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50172 }
50173 arg4 = static_cast< bool >(val4);
50174 }
50175 {
50176 PyThreadState* __tstate = wxPyBeginAllowThreads();
50177 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50178 wxPyEndAllowThreads(__tstate);
50179 if (PyErr_Occurred()) SWIG_fail;
50180 }
50181 {
50182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50183 }
50184 return resultobj;
50185 fail:
50186 return NULL;
50187 }
50188
50189
50190 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50191 PyObject *resultobj = 0;
50192 wxSizer *arg1 = (wxSizer *) 0 ;
50193 wxSizer *arg2 = (wxSizer *) 0 ;
50194 wxSizer *arg3 = (wxSizer *) 0 ;
50195 bool arg4 = (bool) false ;
50196 bool result;
50197 void *argp1 = 0 ;
50198 int res1 = 0 ;
50199 void *argp2 = 0 ;
50200 int res2 = 0 ;
50201 void *argp3 = 0 ;
50202 int res3 = 0 ;
50203 bool val4 ;
50204 int ecode4 = 0 ;
50205 PyObject * obj0 = 0 ;
50206 PyObject * obj1 = 0 ;
50207 PyObject * obj2 = 0 ;
50208 PyObject * obj3 = 0 ;
50209 char * kwnames[] = {
50210 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50211 };
50212
50213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50215 if (!SWIG_IsOK(res1)) {
50216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50217 }
50218 arg1 = reinterpret_cast< wxSizer * >(argp1);
50219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50220 if (!SWIG_IsOK(res2)) {
50221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50222 }
50223 arg2 = reinterpret_cast< wxSizer * >(argp2);
50224 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50225 if (!SWIG_IsOK(res3)) {
50226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50227 }
50228 arg3 = reinterpret_cast< wxSizer * >(argp3);
50229 if (obj3) {
50230 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50231 if (!SWIG_IsOK(ecode4)) {
50232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50233 }
50234 arg4 = static_cast< bool >(val4);
50235 }
50236 {
50237 PyThreadState* __tstate = wxPyBeginAllowThreads();
50238 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50239 wxPyEndAllowThreads(__tstate);
50240 if (PyErr_Occurred()) SWIG_fail;
50241 }
50242 {
50243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50244 }
50245 return resultobj;
50246 fail:
50247 return NULL;
50248 }
50249
50250
50251 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50252 PyObject *resultobj = 0;
50253 wxSizer *arg1 = (wxSizer *) 0 ;
50254 size_t arg2 ;
50255 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50256 bool result;
50257 void *argp1 = 0 ;
50258 int res1 = 0 ;
50259 size_t val2 ;
50260 int ecode2 = 0 ;
50261 void *argp3 = 0 ;
50262 int res3 = 0 ;
50263 PyObject * obj0 = 0 ;
50264 PyObject * obj1 = 0 ;
50265 PyObject * obj2 = 0 ;
50266 char * kwnames[] = {
50267 (char *) "self",(char *) "index",(char *) "newitem", NULL
50268 };
50269
50270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50272 if (!SWIG_IsOK(res1)) {
50273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50274 }
50275 arg1 = reinterpret_cast< wxSizer * >(argp1);
50276 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50277 if (!SWIG_IsOK(ecode2)) {
50278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50279 }
50280 arg2 = static_cast< size_t >(val2);
50281 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50282 if (!SWIG_IsOK(res3)) {
50283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50284 }
50285 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50286 {
50287 PyThreadState* __tstate = wxPyBeginAllowThreads();
50288 result = (bool)(arg1)->Replace(arg2,arg3);
50289 wxPyEndAllowThreads(__tstate);
50290 if (PyErr_Occurred()) SWIG_fail;
50291 }
50292 {
50293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50294 }
50295 return resultobj;
50296 fail:
50297 return NULL;
50298 }
50299
50300
50301 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50302 PyObject *resultobj = 0;
50303 wxSizer *arg1 = (wxSizer *) 0 ;
50304 wxWindow *arg2 = (wxWindow *) 0 ;
50305 void *argp1 = 0 ;
50306 int res1 = 0 ;
50307 void *argp2 = 0 ;
50308 int res2 = 0 ;
50309 PyObject * obj0 = 0 ;
50310 PyObject * obj1 = 0 ;
50311 char * kwnames[] = {
50312 (char *) "self",(char *) "window", NULL
50313 };
50314
50315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50317 if (!SWIG_IsOK(res1)) {
50318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50319 }
50320 arg1 = reinterpret_cast< wxSizer * >(argp1);
50321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50322 if (!SWIG_IsOK(res2)) {
50323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50324 }
50325 arg2 = reinterpret_cast< wxWindow * >(argp2);
50326 {
50327 PyThreadState* __tstate = wxPyBeginAllowThreads();
50328 (arg1)->SetContainingWindow(arg2);
50329 wxPyEndAllowThreads(__tstate);
50330 if (PyErr_Occurred()) SWIG_fail;
50331 }
50332 resultobj = SWIG_Py_Void();
50333 return resultobj;
50334 fail:
50335 return NULL;
50336 }
50337
50338
50339 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50340 PyObject *resultobj = 0;
50341 wxSizer *arg1 = (wxSizer *) 0 ;
50342 wxWindow *result = 0 ;
50343 void *argp1 = 0 ;
50344 int res1 = 0 ;
50345 PyObject *swig_obj[1] ;
50346
50347 if (!args) SWIG_fail;
50348 swig_obj[0] = args;
50349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50350 if (!SWIG_IsOK(res1)) {
50351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50352 }
50353 arg1 = reinterpret_cast< wxSizer * >(argp1);
50354 {
50355 PyThreadState* __tstate = wxPyBeginAllowThreads();
50356 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50357 wxPyEndAllowThreads(__tstate);
50358 if (PyErr_Occurred()) SWIG_fail;
50359 }
50360 {
50361 resultobj = wxPyMake_wxObject(result, 0);
50362 }
50363 return resultobj;
50364 fail:
50365 return NULL;
50366 }
50367
50368
50369 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50370 PyObject *resultobj = 0;
50371 wxSizer *arg1 = (wxSizer *) 0 ;
50372 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50373 wxSizerItem *result = 0 ;
50374 void *argp1 = 0 ;
50375 int res1 = 0 ;
50376 int res2 = 0 ;
50377 PyObject * obj0 = 0 ;
50378 PyObject * obj1 = 0 ;
50379 char * kwnames[] = {
50380 (char *) "self",(char *) "item", NULL
50381 };
50382
50383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50385 if (!SWIG_IsOK(res1)) {
50386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50387 }
50388 arg1 = reinterpret_cast< wxSizer * >(argp1);
50389 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50390 if (!SWIG_IsOK(res2)) {
50391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50392 }
50393 {
50394 PyThreadState* __tstate = wxPyBeginAllowThreads();
50395 result = (wxSizerItem *)(arg1)->Add(arg2);
50396 wxPyEndAllowThreads(__tstate);
50397 if (PyErr_Occurred()) SWIG_fail;
50398 }
50399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50400 return resultobj;
50401 fail:
50402 return NULL;
50403 }
50404
50405
50406 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50407 PyObject *resultobj = 0;
50408 wxSizer *arg1 = (wxSizer *) 0 ;
50409 size_t arg2 ;
50410 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50411 wxSizerItem *result = 0 ;
50412 void *argp1 = 0 ;
50413 int res1 = 0 ;
50414 size_t val2 ;
50415 int ecode2 = 0 ;
50416 int res3 = 0 ;
50417 PyObject * obj0 = 0 ;
50418 PyObject * obj1 = 0 ;
50419 PyObject * obj2 = 0 ;
50420 char * kwnames[] = {
50421 (char *) "self",(char *) "index",(char *) "item", NULL
50422 };
50423
50424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50426 if (!SWIG_IsOK(res1)) {
50427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50428 }
50429 arg1 = reinterpret_cast< wxSizer * >(argp1);
50430 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50431 if (!SWIG_IsOK(ecode2)) {
50432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50433 }
50434 arg2 = static_cast< size_t >(val2);
50435 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50436 if (!SWIG_IsOK(res3)) {
50437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50438 }
50439 {
50440 PyThreadState* __tstate = wxPyBeginAllowThreads();
50441 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50442 wxPyEndAllowThreads(__tstate);
50443 if (PyErr_Occurred()) SWIG_fail;
50444 }
50445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50446 return resultobj;
50447 fail:
50448 return NULL;
50449 }
50450
50451
50452 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50453 PyObject *resultobj = 0;
50454 wxSizer *arg1 = (wxSizer *) 0 ;
50455 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50456 wxSizerItem *result = 0 ;
50457 void *argp1 = 0 ;
50458 int res1 = 0 ;
50459 int res2 = 0 ;
50460 PyObject * obj0 = 0 ;
50461 PyObject * obj1 = 0 ;
50462 char * kwnames[] = {
50463 (char *) "self",(char *) "item", NULL
50464 };
50465
50466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50468 if (!SWIG_IsOK(res1)) {
50469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50470 }
50471 arg1 = reinterpret_cast< wxSizer * >(argp1);
50472 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50473 if (!SWIG_IsOK(res2)) {
50474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50475 }
50476 {
50477 PyThreadState* __tstate = wxPyBeginAllowThreads();
50478 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50479 wxPyEndAllowThreads(__tstate);
50480 if (PyErr_Occurred()) SWIG_fail;
50481 }
50482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50483 return resultobj;
50484 fail:
50485 return NULL;
50486 }
50487
50488
50489 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50490 PyObject *resultobj = 0;
50491 wxSizer *arg1 = (wxSizer *) 0 ;
50492 int arg2 ;
50493 int arg3 ;
50494 int arg4 ;
50495 int arg5 ;
50496 void *argp1 = 0 ;
50497 int res1 = 0 ;
50498 int val2 ;
50499 int ecode2 = 0 ;
50500 int val3 ;
50501 int ecode3 = 0 ;
50502 int val4 ;
50503 int ecode4 = 0 ;
50504 int val5 ;
50505 int ecode5 = 0 ;
50506 PyObject * obj0 = 0 ;
50507 PyObject * obj1 = 0 ;
50508 PyObject * obj2 = 0 ;
50509 PyObject * obj3 = 0 ;
50510 PyObject * obj4 = 0 ;
50511 char * kwnames[] = {
50512 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50513 };
50514
50515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50517 if (!SWIG_IsOK(res1)) {
50518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50519 }
50520 arg1 = reinterpret_cast< wxSizer * >(argp1);
50521 ecode2 = SWIG_AsVal_int(obj1, &val2);
50522 if (!SWIG_IsOK(ecode2)) {
50523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50524 }
50525 arg2 = static_cast< int >(val2);
50526 ecode3 = SWIG_AsVal_int(obj2, &val3);
50527 if (!SWIG_IsOK(ecode3)) {
50528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50529 }
50530 arg3 = static_cast< int >(val3);
50531 ecode4 = SWIG_AsVal_int(obj3, &val4);
50532 if (!SWIG_IsOK(ecode4)) {
50533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50534 }
50535 arg4 = static_cast< int >(val4);
50536 ecode5 = SWIG_AsVal_int(obj4, &val5);
50537 if (!SWIG_IsOK(ecode5)) {
50538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50539 }
50540 arg5 = static_cast< int >(val5);
50541 {
50542 PyThreadState* __tstate = wxPyBeginAllowThreads();
50543 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50544 wxPyEndAllowThreads(__tstate);
50545 if (PyErr_Occurred()) SWIG_fail;
50546 }
50547 resultobj = SWIG_Py_Void();
50548 return resultobj;
50549 fail:
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50555 PyObject *resultobj = 0;
50556 wxSizer *arg1 = (wxSizer *) 0 ;
50557 wxSize *arg2 = 0 ;
50558 void *argp1 = 0 ;
50559 int res1 = 0 ;
50560 wxSize temp2 ;
50561 PyObject * obj0 = 0 ;
50562 PyObject * obj1 = 0 ;
50563 char * kwnames[] = {
50564 (char *) "self",(char *) "size", NULL
50565 };
50566
50567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50569 if (!SWIG_IsOK(res1)) {
50570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50571 }
50572 arg1 = reinterpret_cast< wxSizer * >(argp1);
50573 {
50574 arg2 = &temp2;
50575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50576 }
50577 {
50578 PyThreadState* __tstate = wxPyBeginAllowThreads();
50579 (arg1)->SetMinSize((wxSize const &)*arg2);
50580 wxPyEndAllowThreads(__tstate);
50581 if (PyErr_Occurred()) SWIG_fail;
50582 }
50583 resultobj = SWIG_Py_Void();
50584 return resultobj;
50585 fail:
50586 return NULL;
50587 }
50588
50589
50590 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50591 PyObject *resultobj = 0;
50592 wxSizer *arg1 = (wxSizer *) 0 ;
50593 wxSize result;
50594 void *argp1 = 0 ;
50595 int res1 = 0 ;
50596 PyObject *swig_obj[1] ;
50597
50598 if (!args) SWIG_fail;
50599 swig_obj[0] = args;
50600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50601 if (!SWIG_IsOK(res1)) {
50602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50603 }
50604 arg1 = reinterpret_cast< wxSizer * >(argp1);
50605 {
50606 PyThreadState* __tstate = wxPyBeginAllowThreads();
50607 result = (arg1)->GetSize();
50608 wxPyEndAllowThreads(__tstate);
50609 if (PyErr_Occurred()) SWIG_fail;
50610 }
50611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50612 return resultobj;
50613 fail:
50614 return NULL;
50615 }
50616
50617
50618 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50619 PyObject *resultobj = 0;
50620 wxSizer *arg1 = (wxSizer *) 0 ;
50621 wxPoint result;
50622 void *argp1 = 0 ;
50623 int res1 = 0 ;
50624 PyObject *swig_obj[1] ;
50625
50626 if (!args) SWIG_fail;
50627 swig_obj[0] = args;
50628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50629 if (!SWIG_IsOK(res1)) {
50630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50631 }
50632 arg1 = reinterpret_cast< wxSizer * >(argp1);
50633 {
50634 PyThreadState* __tstate = wxPyBeginAllowThreads();
50635 result = (arg1)->GetPosition();
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50647 PyObject *resultobj = 0;
50648 wxSizer *arg1 = (wxSizer *) 0 ;
50649 wxSize result;
50650 void *argp1 = 0 ;
50651 int res1 = 0 ;
50652 PyObject *swig_obj[1] ;
50653
50654 if (!args) SWIG_fail;
50655 swig_obj[0] = args;
50656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50657 if (!SWIG_IsOK(res1)) {
50658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50659 }
50660 arg1 = reinterpret_cast< wxSizer * >(argp1);
50661 {
50662 PyThreadState* __tstate = wxPyBeginAllowThreads();
50663 result = (arg1)->GetMinSize();
50664 wxPyEndAllowThreads(__tstate);
50665 if (PyErr_Occurred()) SWIG_fail;
50666 }
50667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50668 return resultobj;
50669 fail:
50670 return NULL;
50671 }
50672
50673
50674 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50675 PyObject *resultobj = 0;
50676 wxSizer *arg1 = (wxSizer *) 0 ;
50677 void *argp1 = 0 ;
50678 int res1 = 0 ;
50679 PyObject *swig_obj[1] ;
50680
50681 if (!args) SWIG_fail;
50682 swig_obj[0] = args;
50683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50684 if (!SWIG_IsOK(res1)) {
50685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50686 }
50687 arg1 = reinterpret_cast< wxSizer * >(argp1);
50688 {
50689 PyThreadState* __tstate = wxPyBeginAllowThreads();
50690 (arg1)->RecalcSizes();
50691 wxPyEndAllowThreads(__tstate);
50692 if (PyErr_Occurred()) SWIG_fail;
50693 }
50694 resultobj = SWIG_Py_Void();
50695 return resultobj;
50696 fail:
50697 return NULL;
50698 }
50699
50700
50701 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50702 PyObject *resultobj = 0;
50703 wxSizer *arg1 = (wxSizer *) 0 ;
50704 wxSize result;
50705 void *argp1 = 0 ;
50706 int res1 = 0 ;
50707 PyObject *swig_obj[1] ;
50708
50709 if (!args) SWIG_fail;
50710 swig_obj[0] = args;
50711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50712 if (!SWIG_IsOK(res1)) {
50713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50714 }
50715 arg1 = reinterpret_cast< wxSizer * >(argp1);
50716 {
50717 PyThreadState* __tstate = wxPyBeginAllowThreads();
50718 result = (arg1)->CalcMin();
50719 wxPyEndAllowThreads(__tstate);
50720 if (PyErr_Occurred()) SWIG_fail;
50721 }
50722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50723 return resultobj;
50724 fail:
50725 return NULL;
50726 }
50727
50728
50729 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50730 PyObject *resultobj = 0;
50731 wxSizer *arg1 = (wxSizer *) 0 ;
50732 void *argp1 = 0 ;
50733 int res1 = 0 ;
50734 PyObject *swig_obj[1] ;
50735
50736 if (!args) SWIG_fail;
50737 swig_obj[0] = args;
50738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50739 if (!SWIG_IsOK(res1)) {
50740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50741 }
50742 arg1 = reinterpret_cast< wxSizer * >(argp1);
50743 {
50744 PyThreadState* __tstate = wxPyBeginAllowThreads();
50745 (arg1)->Layout();
50746 wxPyEndAllowThreads(__tstate);
50747 if (PyErr_Occurred()) SWIG_fail;
50748 }
50749 resultobj = SWIG_Py_Void();
50750 return resultobj;
50751 fail:
50752 return NULL;
50753 }
50754
50755
50756 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50757 PyObject *resultobj = 0;
50758 wxSizer *arg1 = (wxSizer *) 0 ;
50759 wxWindow *arg2 = (wxWindow *) 0 ;
50760 wxSize result;
50761 void *argp1 = 0 ;
50762 int res1 = 0 ;
50763 void *argp2 = 0 ;
50764 int res2 = 0 ;
50765 PyObject * obj0 = 0 ;
50766 PyObject * obj1 = 0 ;
50767 char * kwnames[] = {
50768 (char *) "self",(char *) "window", NULL
50769 };
50770
50771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res1)) {
50774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50775 }
50776 arg1 = reinterpret_cast< wxSizer * >(argp1);
50777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50778 if (!SWIG_IsOK(res2)) {
50779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50780 }
50781 arg2 = reinterpret_cast< wxWindow * >(argp2);
50782 {
50783 PyThreadState* __tstate = wxPyBeginAllowThreads();
50784 result = (arg1)->Fit(arg2);
50785 wxPyEndAllowThreads(__tstate);
50786 if (PyErr_Occurred()) SWIG_fail;
50787 }
50788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50789 return resultobj;
50790 fail:
50791 return NULL;
50792 }
50793
50794
50795 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50796 PyObject *resultobj = 0;
50797 wxSizer *arg1 = (wxSizer *) 0 ;
50798 wxWindow *arg2 = (wxWindow *) 0 ;
50799 void *argp1 = 0 ;
50800 int res1 = 0 ;
50801 void *argp2 = 0 ;
50802 int res2 = 0 ;
50803 PyObject * obj0 = 0 ;
50804 PyObject * obj1 = 0 ;
50805 char * kwnames[] = {
50806 (char *) "self",(char *) "window", NULL
50807 };
50808
50809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50811 if (!SWIG_IsOK(res1)) {
50812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50813 }
50814 arg1 = reinterpret_cast< wxSizer * >(argp1);
50815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50816 if (!SWIG_IsOK(res2)) {
50817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50818 }
50819 arg2 = reinterpret_cast< wxWindow * >(argp2);
50820 {
50821 PyThreadState* __tstate = wxPyBeginAllowThreads();
50822 (arg1)->FitInside(arg2);
50823 wxPyEndAllowThreads(__tstate);
50824 if (PyErr_Occurred()) SWIG_fail;
50825 }
50826 resultobj = SWIG_Py_Void();
50827 return resultobj;
50828 fail:
50829 return NULL;
50830 }
50831
50832
50833 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50834 PyObject *resultobj = 0;
50835 wxSizer *arg1 = (wxSizer *) 0 ;
50836 wxWindow *arg2 = (wxWindow *) 0 ;
50837 void *argp1 = 0 ;
50838 int res1 = 0 ;
50839 void *argp2 = 0 ;
50840 int res2 = 0 ;
50841 PyObject * obj0 = 0 ;
50842 PyObject * obj1 = 0 ;
50843 char * kwnames[] = {
50844 (char *) "self",(char *) "window", NULL
50845 };
50846
50847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50849 if (!SWIG_IsOK(res1)) {
50850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50851 }
50852 arg1 = reinterpret_cast< wxSizer * >(argp1);
50853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50854 if (!SWIG_IsOK(res2)) {
50855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50856 }
50857 arg2 = reinterpret_cast< wxWindow * >(argp2);
50858 {
50859 PyThreadState* __tstate = wxPyBeginAllowThreads();
50860 (arg1)->SetSizeHints(arg2);
50861 wxPyEndAllowThreads(__tstate);
50862 if (PyErr_Occurred()) SWIG_fail;
50863 }
50864 resultobj = SWIG_Py_Void();
50865 return resultobj;
50866 fail:
50867 return NULL;
50868 }
50869
50870
50871 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50872 PyObject *resultobj = 0;
50873 wxSizer *arg1 = (wxSizer *) 0 ;
50874 wxWindow *arg2 = (wxWindow *) 0 ;
50875 void *argp1 = 0 ;
50876 int res1 = 0 ;
50877 void *argp2 = 0 ;
50878 int res2 = 0 ;
50879 PyObject * obj0 = 0 ;
50880 PyObject * obj1 = 0 ;
50881 char * kwnames[] = {
50882 (char *) "self",(char *) "window", NULL
50883 };
50884
50885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50887 if (!SWIG_IsOK(res1)) {
50888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50889 }
50890 arg1 = reinterpret_cast< wxSizer * >(argp1);
50891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50892 if (!SWIG_IsOK(res2)) {
50893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50894 }
50895 arg2 = reinterpret_cast< wxWindow * >(argp2);
50896 {
50897 PyThreadState* __tstate = wxPyBeginAllowThreads();
50898 (arg1)->SetVirtualSizeHints(arg2);
50899 wxPyEndAllowThreads(__tstate);
50900 if (PyErr_Occurred()) SWIG_fail;
50901 }
50902 resultobj = SWIG_Py_Void();
50903 return resultobj;
50904 fail:
50905 return NULL;
50906 }
50907
50908
50909 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50910 PyObject *resultobj = 0;
50911 wxSizer *arg1 = (wxSizer *) 0 ;
50912 bool arg2 = (bool) false ;
50913 void *argp1 = 0 ;
50914 int res1 = 0 ;
50915 bool val2 ;
50916 int ecode2 = 0 ;
50917 PyObject * obj0 = 0 ;
50918 PyObject * obj1 = 0 ;
50919 char * kwnames[] = {
50920 (char *) "self",(char *) "deleteWindows", NULL
50921 };
50922
50923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50925 if (!SWIG_IsOK(res1)) {
50926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50927 }
50928 arg1 = reinterpret_cast< wxSizer * >(argp1);
50929 if (obj1) {
50930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50931 if (!SWIG_IsOK(ecode2)) {
50932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50933 }
50934 arg2 = static_cast< bool >(val2);
50935 }
50936 {
50937 PyThreadState* __tstate = wxPyBeginAllowThreads();
50938 (arg1)->Clear(arg2);
50939 wxPyEndAllowThreads(__tstate);
50940 if (PyErr_Occurred()) SWIG_fail;
50941 }
50942 resultobj = SWIG_Py_Void();
50943 return resultobj;
50944 fail:
50945 return NULL;
50946 }
50947
50948
50949 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50950 PyObject *resultobj = 0;
50951 wxSizer *arg1 = (wxSizer *) 0 ;
50952 void *argp1 = 0 ;
50953 int res1 = 0 ;
50954 PyObject *swig_obj[1] ;
50955
50956 if (!args) SWIG_fail;
50957 swig_obj[0] = args;
50958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50959 if (!SWIG_IsOK(res1)) {
50960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50961 }
50962 arg1 = reinterpret_cast< wxSizer * >(argp1);
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 (arg1)->DeleteWindows();
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 resultobj = SWIG_Py_Void();
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50977 PyObject *resultobj = 0;
50978 wxSizer *arg1 = (wxSizer *) 0 ;
50979 PyObject *result = 0 ;
50980 void *argp1 = 0 ;
50981 int res1 = 0 ;
50982 PyObject *swig_obj[1] ;
50983
50984 if (!args) SWIG_fail;
50985 swig_obj[0] = args;
50986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50987 if (!SWIG_IsOK(res1)) {
50988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50989 }
50990 arg1 = reinterpret_cast< wxSizer * >(argp1);
50991 {
50992 PyThreadState* __tstate = wxPyBeginAllowThreads();
50993 result = (PyObject *)wxSizer_GetChildren(arg1);
50994 wxPyEndAllowThreads(__tstate);
50995 if (PyErr_Occurred()) SWIG_fail;
50996 }
50997 resultobj = result;
50998 return resultobj;
50999 fail:
51000 return NULL;
51001 }
51002
51003
51004 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51005 PyObject *resultobj = 0;
51006 wxSizer *arg1 = (wxSizer *) 0 ;
51007 PyObject *arg2 = (PyObject *) 0 ;
51008 bool arg3 = (bool) true ;
51009 bool arg4 = (bool) false ;
51010 bool result;
51011 void *argp1 = 0 ;
51012 int res1 = 0 ;
51013 bool val3 ;
51014 int ecode3 = 0 ;
51015 bool val4 ;
51016 int ecode4 = 0 ;
51017 PyObject * obj0 = 0 ;
51018 PyObject * obj1 = 0 ;
51019 PyObject * obj2 = 0 ;
51020 PyObject * obj3 = 0 ;
51021 char * kwnames[] = {
51022 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51023 };
51024
51025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51027 if (!SWIG_IsOK(res1)) {
51028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51029 }
51030 arg1 = reinterpret_cast< wxSizer * >(argp1);
51031 arg2 = obj1;
51032 if (obj2) {
51033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51034 if (!SWIG_IsOK(ecode3)) {
51035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51036 }
51037 arg3 = static_cast< bool >(val3);
51038 }
51039 if (obj3) {
51040 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51041 if (!SWIG_IsOK(ecode4)) {
51042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51043 }
51044 arg4 = static_cast< bool >(val4);
51045 }
51046 {
51047 PyThreadState* __tstate = wxPyBeginAllowThreads();
51048 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51049 wxPyEndAllowThreads(__tstate);
51050 if (PyErr_Occurred()) SWIG_fail;
51051 }
51052 {
51053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51054 }
51055 return resultobj;
51056 fail:
51057 return NULL;
51058 }
51059
51060
51061 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51062 PyObject *resultobj = 0;
51063 wxSizer *arg1 = (wxSizer *) 0 ;
51064 PyObject *arg2 = (PyObject *) 0 ;
51065 bool result;
51066 void *argp1 = 0 ;
51067 int res1 = 0 ;
51068 PyObject * obj0 = 0 ;
51069 PyObject * obj1 = 0 ;
51070 char * kwnames[] = {
51071 (char *) "self",(char *) "item", NULL
51072 };
51073
51074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51076 if (!SWIG_IsOK(res1)) {
51077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51078 }
51079 arg1 = reinterpret_cast< wxSizer * >(argp1);
51080 arg2 = obj1;
51081 {
51082 PyThreadState* __tstate = wxPyBeginAllowThreads();
51083 result = (bool)wxSizer_IsShown(arg1,arg2);
51084 wxPyEndAllowThreads(__tstate);
51085 if (PyErr_Occurred()) SWIG_fail;
51086 }
51087 {
51088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51089 }
51090 return resultobj;
51091 fail:
51092 return NULL;
51093 }
51094
51095
51096 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51097 PyObject *resultobj = 0;
51098 wxSizer *arg1 = (wxSizer *) 0 ;
51099 bool arg2 ;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 bool val2 ;
51103 int ecode2 = 0 ;
51104 PyObject * obj0 = 0 ;
51105 PyObject * obj1 = 0 ;
51106 char * kwnames[] = {
51107 (char *) "self",(char *) "show", NULL
51108 };
51109
51110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51112 if (!SWIG_IsOK(res1)) {
51113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51114 }
51115 arg1 = reinterpret_cast< wxSizer * >(argp1);
51116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51117 if (!SWIG_IsOK(ecode2)) {
51118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51119 }
51120 arg2 = static_cast< bool >(val2);
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 (arg1)->ShowItems(arg2);
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = SWIG_Py_Void();
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51135 PyObject *obj;
51136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51137 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51138 return SWIG_Py_Void();
51139 }
51140
51141 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51142 PyObject *resultobj = 0;
51143 wxPySizer *result = 0 ;
51144
51145 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51146 {
51147 PyThreadState* __tstate = wxPyBeginAllowThreads();
51148 result = (wxPySizer *)new wxPySizer();
51149 wxPyEndAllowThreads(__tstate);
51150 if (PyErr_Occurred()) SWIG_fail;
51151 }
51152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51153 return resultobj;
51154 fail:
51155 return NULL;
51156 }
51157
51158
51159 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51160 PyObject *resultobj = 0;
51161 wxPySizer *arg1 = (wxPySizer *) 0 ;
51162 PyObject *arg2 = (PyObject *) 0 ;
51163 PyObject *arg3 = (PyObject *) 0 ;
51164 void *argp1 = 0 ;
51165 int res1 = 0 ;
51166 PyObject * obj0 = 0 ;
51167 PyObject * obj1 = 0 ;
51168 PyObject * obj2 = 0 ;
51169 char * kwnames[] = {
51170 (char *) "self",(char *) "self",(char *) "_class", NULL
51171 };
51172
51173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51175 if (!SWIG_IsOK(res1)) {
51176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51177 }
51178 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51179 arg2 = obj1;
51180 arg3 = obj2;
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 (arg1)->_setCallbackInfo(arg2,arg3);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 resultobj = SWIG_Py_Void();
51188 return resultobj;
51189 fail:
51190 return NULL;
51191 }
51192
51193
51194 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51195 PyObject *obj;
51196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51197 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51198 return SWIG_Py_Void();
51199 }
51200
51201 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51202 return SWIG_Python_InitShadowInstance(args);
51203 }
51204
51205 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51206 PyObject *resultobj = 0;
51207 int arg1 = (int) wxHORIZONTAL ;
51208 wxBoxSizer *result = 0 ;
51209 int val1 ;
51210 int ecode1 = 0 ;
51211 PyObject * obj0 = 0 ;
51212 char * kwnames[] = {
51213 (char *) "orient", NULL
51214 };
51215
51216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51217 if (obj0) {
51218 ecode1 = SWIG_AsVal_int(obj0, &val1);
51219 if (!SWIG_IsOK(ecode1)) {
51220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51221 }
51222 arg1 = static_cast< int >(val1);
51223 }
51224 {
51225 PyThreadState* __tstate = wxPyBeginAllowThreads();
51226 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51227 wxPyEndAllowThreads(__tstate);
51228 if (PyErr_Occurred()) SWIG_fail;
51229 }
51230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51231 return resultobj;
51232 fail:
51233 return NULL;
51234 }
51235
51236
51237 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51238 PyObject *resultobj = 0;
51239 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51240 int result;
51241 void *argp1 = 0 ;
51242 int res1 = 0 ;
51243 PyObject *swig_obj[1] ;
51244
51245 if (!args) SWIG_fail;
51246 swig_obj[0] = args;
51247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51250 }
51251 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51252 {
51253 PyThreadState* __tstate = wxPyBeginAllowThreads();
51254 result = (int)(arg1)->GetOrientation();
51255 wxPyEndAllowThreads(__tstate);
51256 if (PyErr_Occurred()) SWIG_fail;
51257 }
51258 resultobj = SWIG_From_int(static_cast< int >(result));
51259 return resultobj;
51260 fail:
51261 return NULL;
51262 }
51263
51264
51265 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51266 PyObject *resultobj = 0;
51267 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51268 int arg2 ;
51269 void *argp1 = 0 ;
51270 int res1 = 0 ;
51271 int val2 ;
51272 int ecode2 = 0 ;
51273 PyObject * obj0 = 0 ;
51274 PyObject * obj1 = 0 ;
51275 char * kwnames[] = {
51276 (char *) "self",(char *) "orient", NULL
51277 };
51278
51279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51281 if (!SWIG_IsOK(res1)) {
51282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51283 }
51284 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51285 ecode2 = SWIG_AsVal_int(obj1, &val2);
51286 if (!SWIG_IsOK(ecode2)) {
51287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51288 }
51289 arg2 = static_cast< int >(val2);
51290 {
51291 PyThreadState* __tstate = wxPyBeginAllowThreads();
51292 (arg1)->SetOrientation(arg2);
51293 wxPyEndAllowThreads(__tstate);
51294 if (PyErr_Occurred()) SWIG_fail;
51295 }
51296 resultobj = SWIG_Py_Void();
51297 return resultobj;
51298 fail:
51299 return NULL;
51300 }
51301
51302
51303 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51304 PyObject *obj;
51305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51306 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51307 return SWIG_Py_Void();
51308 }
51309
51310 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51311 return SWIG_Python_InitShadowInstance(args);
51312 }
51313
51314 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51315 PyObject *resultobj = 0;
51316 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51317 int arg2 = (int) wxHORIZONTAL ;
51318 wxStaticBoxSizer *result = 0 ;
51319 void *argp1 = 0 ;
51320 int res1 = 0 ;
51321 int val2 ;
51322 int ecode2 = 0 ;
51323 PyObject * obj0 = 0 ;
51324 PyObject * obj1 = 0 ;
51325 char * kwnames[] = {
51326 (char *) "box",(char *) "orient", NULL
51327 };
51328
51329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51331 if (!SWIG_IsOK(res1)) {
51332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51333 }
51334 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51335 if (obj1) {
51336 ecode2 = SWIG_AsVal_int(obj1, &val2);
51337 if (!SWIG_IsOK(ecode2)) {
51338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51339 }
51340 arg2 = static_cast< int >(val2);
51341 }
51342 {
51343 PyThreadState* __tstate = wxPyBeginAllowThreads();
51344 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51345 wxPyEndAllowThreads(__tstate);
51346 if (PyErr_Occurred()) SWIG_fail;
51347 }
51348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51349 return resultobj;
51350 fail:
51351 return NULL;
51352 }
51353
51354
51355 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51356 PyObject *resultobj = 0;
51357 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51358 wxStaticBox *result = 0 ;
51359 void *argp1 = 0 ;
51360 int res1 = 0 ;
51361 PyObject *swig_obj[1] ;
51362
51363 if (!args) SWIG_fail;
51364 swig_obj[0] = args;
51365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51366 if (!SWIG_IsOK(res1)) {
51367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51368 }
51369 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51370 {
51371 PyThreadState* __tstate = wxPyBeginAllowThreads();
51372 result = (wxStaticBox *)(arg1)->GetStaticBox();
51373 wxPyEndAllowThreads(__tstate);
51374 if (PyErr_Occurred()) SWIG_fail;
51375 }
51376 {
51377 resultobj = wxPyMake_wxObject(result, (bool)0);
51378 }
51379 return resultobj;
51380 fail:
51381 return NULL;
51382 }
51383
51384
51385 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51386 PyObject *obj;
51387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51388 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51389 return SWIG_Py_Void();
51390 }
51391
51392 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51393 return SWIG_Python_InitShadowInstance(args);
51394 }
51395
51396 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51397 PyObject *resultobj = 0;
51398 int arg1 = (int) 1 ;
51399 int arg2 = (int) 0 ;
51400 int arg3 = (int) 0 ;
51401 int arg4 = (int) 0 ;
51402 wxGridSizer *result = 0 ;
51403 int val1 ;
51404 int ecode1 = 0 ;
51405 int val2 ;
51406 int ecode2 = 0 ;
51407 int val3 ;
51408 int ecode3 = 0 ;
51409 int val4 ;
51410 int ecode4 = 0 ;
51411 PyObject * obj0 = 0 ;
51412 PyObject * obj1 = 0 ;
51413 PyObject * obj2 = 0 ;
51414 PyObject * obj3 = 0 ;
51415 char * kwnames[] = {
51416 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51417 };
51418
51419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51420 if (obj0) {
51421 ecode1 = SWIG_AsVal_int(obj0, &val1);
51422 if (!SWIG_IsOK(ecode1)) {
51423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51424 }
51425 arg1 = static_cast< int >(val1);
51426 }
51427 if (obj1) {
51428 ecode2 = SWIG_AsVal_int(obj1, &val2);
51429 if (!SWIG_IsOK(ecode2)) {
51430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51431 }
51432 arg2 = static_cast< int >(val2);
51433 }
51434 if (obj2) {
51435 ecode3 = SWIG_AsVal_int(obj2, &val3);
51436 if (!SWIG_IsOK(ecode3)) {
51437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51438 }
51439 arg3 = static_cast< int >(val3);
51440 }
51441 if (obj3) {
51442 ecode4 = SWIG_AsVal_int(obj3, &val4);
51443 if (!SWIG_IsOK(ecode4)) {
51444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51445 }
51446 arg4 = static_cast< int >(val4);
51447 }
51448 {
51449 PyThreadState* __tstate = wxPyBeginAllowThreads();
51450 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51451 wxPyEndAllowThreads(__tstate);
51452 if (PyErr_Occurred()) SWIG_fail;
51453 }
51454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51455 return resultobj;
51456 fail:
51457 return NULL;
51458 }
51459
51460
51461 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51462 PyObject *resultobj = 0;
51463 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51464 int arg2 ;
51465 void *argp1 = 0 ;
51466 int res1 = 0 ;
51467 int val2 ;
51468 int ecode2 = 0 ;
51469 PyObject * obj0 = 0 ;
51470 PyObject * obj1 = 0 ;
51471 char * kwnames[] = {
51472 (char *) "self",(char *) "cols", NULL
51473 };
51474
51475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51477 if (!SWIG_IsOK(res1)) {
51478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51479 }
51480 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51481 ecode2 = SWIG_AsVal_int(obj1, &val2);
51482 if (!SWIG_IsOK(ecode2)) {
51483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51484 }
51485 arg2 = static_cast< int >(val2);
51486 {
51487 PyThreadState* __tstate = wxPyBeginAllowThreads();
51488 (arg1)->SetCols(arg2);
51489 wxPyEndAllowThreads(__tstate);
51490 if (PyErr_Occurred()) SWIG_fail;
51491 }
51492 resultobj = SWIG_Py_Void();
51493 return resultobj;
51494 fail:
51495 return NULL;
51496 }
51497
51498
51499 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51500 PyObject *resultobj = 0;
51501 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51502 int arg2 ;
51503 void *argp1 = 0 ;
51504 int res1 = 0 ;
51505 int val2 ;
51506 int ecode2 = 0 ;
51507 PyObject * obj0 = 0 ;
51508 PyObject * obj1 = 0 ;
51509 char * kwnames[] = {
51510 (char *) "self",(char *) "rows", NULL
51511 };
51512
51513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51515 if (!SWIG_IsOK(res1)) {
51516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51517 }
51518 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51519 ecode2 = SWIG_AsVal_int(obj1, &val2);
51520 if (!SWIG_IsOK(ecode2)) {
51521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51522 }
51523 arg2 = static_cast< int >(val2);
51524 {
51525 PyThreadState* __tstate = wxPyBeginAllowThreads();
51526 (arg1)->SetRows(arg2);
51527 wxPyEndAllowThreads(__tstate);
51528 if (PyErr_Occurred()) SWIG_fail;
51529 }
51530 resultobj = SWIG_Py_Void();
51531 return resultobj;
51532 fail:
51533 return NULL;
51534 }
51535
51536
51537 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51538 PyObject *resultobj = 0;
51539 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51540 int arg2 ;
51541 void *argp1 = 0 ;
51542 int res1 = 0 ;
51543 int val2 ;
51544 int ecode2 = 0 ;
51545 PyObject * obj0 = 0 ;
51546 PyObject * obj1 = 0 ;
51547 char * kwnames[] = {
51548 (char *) "self",(char *) "gap", NULL
51549 };
51550
51551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51553 if (!SWIG_IsOK(res1)) {
51554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51555 }
51556 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51557 ecode2 = SWIG_AsVal_int(obj1, &val2);
51558 if (!SWIG_IsOK(ecode2)) {
51559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51560 }
51561 arg2 = static_cast< int >(val2);
51562 {
51563 PyThreadState* __tstate = wxPyBeginAllowThreads();
51564 (arg1)->SetVGap(arg2);
51565 wxPyEndAllowThreads(__tstate);
51566 if (PyErr_Occurred()) SWIG_fail;
51567 }
51568 resultobj = SWIG_Py_Void();
51569 return resultobj;
51570 fail:
51571 return NULL;
51572 }
51573
51574
51575 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51576 PyObject *resultobj = 0;
51577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51578 int arg2 ;
51579 void *argp1 = 0 ;
51580 int res1 = 0 ;
51581 int val2 ;
51582 int ecode2 = 0 ;
51583 PyObject * obj0 = 0 ;
51584 PyObject * obj1 = 0 ;
51585 char * kwnames[] = {
51586 (char *) "self",(char *) "gap", NULL
51587 };
51588
51589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51591 if (!SWIG_IsOK(res1)) {
51592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51593 }
51594 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51595 ecode2 = SWIG_AsVal_int(obj1, &val2);
51596 if (!SWIG_IsOK(ecode2)) {
51597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51598 }
51599 arg2 = static_cast< int >(val2);
51600 {
51601 PyThreadState* __tstate = wxPyBeginAllowThreads();
51602 (arg1)->SetHGap(arg2);
51603 wxPyEndAllowThreads(__tstate);
51604 if (PyErr_Occurred()) SWIG_fail;
51605 }
51606 resultobj = SWIG_Py_Void();
51607 return resultobj;
51608 fail:
51609 return NULL;
51610 }
51611
51612
51613 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51614 PyObject *resultobj = 0;
51615 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51616 int result;
51617 void *argp1 = 0 ;
51618 int res1 = 0 ;
51619 PyObject *swig_obj[1] ;
51620
51621 if (!args) SWIG_fail;
51622 swig_obj[0] = args;
51623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51624 if (!SWIG_IsOK(res1)) {
51625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51626 }
51627 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51628 {
51629 PyThreadState* __tstate = wxPyBeginAllowThreads();
51630 result = (int)(arg1)->GetCols();
51631 wxPyEndAllowThreads(__tstate);
51632 if (PyErr_Occurred()) SWIG_fail;
51633 }
51634 resultobj = SWIG_From_int(static_cast< int >(result));
51635 return resultobj;
51636 fail:
51637 return NULL;
51638 }
51639
51640
51641 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51642 PyObject *resultobj = 0;
51643 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51644 int result;
51645 void *argp1 = 0 ;
51646 int res1 = 0 ;
51647 PyObject *swig_obj[1] ;
51648
51649 if (!args) SWIG_fail;
51650 swig_obj[0] = args;
51651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51652 if (!SWIG_IsOK(res1)) {
51653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51654 }
51655 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51656 {
51657 PyThreadState* __tstate = wxPyBeginAllowThreads();
51658 result = (int)(arg1)->GetRows();
51659 wxPyEndAllowThreads(__tstate);
51660 if (PyErr_Occurred()) SWIG_fail;
51661 }
51662 resultobj = SWIG_From_int(static_cast< int >(result));
51663 return resultobj;
51664 fail:
51665 return NULL;
51666 }
51667
51668
51669 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51670 PyObject *resultobj = 0;
51671 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51672 int result;
51673 void *argp1 = 0 ;
51674 int res1 = 0 ;
51675 PyObject *swig_obj[1] ;
51676
51677 if (!args) SWIG_fail;
51678 swig_obj[0] = args;
51679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51680 if (!SWIG_IsOK(res1)) {
51681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51682 }
51683 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 result = (int)(arg1)->GetVGap();
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 resultobj = SWIG_From_int(static_cast< int >(result));
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51698 PyObject *resultobj = 0;
51699 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51700 int result;
51701 void *argp1 = 0 ;
51702 int res1 = 0 ;
51703 PyObject *swig_obj[1] ;
51704
51705 if (!args) SWIG_fail;
51706 swig_obj[0] = args;
51707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51708 if (!SWIG_IsOK(res1)) {
51709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51710 }
51711 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51712 {
51713 PyThreadState* __tstate = wxPyBeginAllowThreads();
51714 result = (int)(arg1)->GetHGap();
51715 wxPyEndAllowThreads(__tstate);
51716 if (PyErr_Occurred()) SWIG_fail;
51717 }
51718 resultobj = SWIG_From_int(static_cast< int >(result));
51719 return resultobj;
51720 fail:
51721 return NULL;
51722 }
51723
51724
51725 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51726 PyObject *obj;
51727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51728 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51729 return SWIG_Py_Void();
51730 }
51731
51732 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51733 return SWIG_Python_InitShadowInstance(args);
51734 }
51735
51736 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51737 PyObject *resultobj = 0;
51738 int arg1 = (int) 1 ;
51739 int arg2 = (int) 0 ;
51740 int arg3 = (int) 0 ;
51741 int arg4 = (int) 0 ;
51742 wxFlexGridSizer *result = 0 ;
51743 int val1 ;
51744 int ecode1 = 0 ;
51745 int val2 ;
51746 int ecode2 = 0 ;
51747 int val3 ;
51748 int ecode3 = 0 ;
51749 int val4 ;
51750 int ecode4 = 0 ;
51751 PyObject * obj0 = 0 ;
51752 PyObject * obj1 = 0 ;
51753 PyObject * obj2 = 0 ;
51754 PyObject * obj3 = 0 ;
51755 char * kwnames[] = {
51756 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51757 };
51758
51759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51760 if (obj0) {
51761 ecode1 = SWIG_AsVal_int(obj0, &val1);
51762 if (!SWIG_IsOK(ecode1)) {
51763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51764 }
51765 arg1 = static_cast< int >(val1);
51766 }
51767 if (obj1) {
51768 ecode2 = SWIG_AsVal_int(obj1, &val2);
51769 if (!SWIG_IsOK(ecode2)) {
51770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51771 }
51772 arg2 = static_cast< int >(val2);
51773 }
51774 if (obj2) {
51775 ecode3 = SWIG_AsVal_int(obj2, &val3);
51776 if (!SWIG_IsOK(ecode3)) {
51777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51778 }
51779 arg3 = static_cast< int >(val3);
51780 }
51781 if (obj3) {
51782 ecode4 = SWIG_AsVal_int(obj3, &val4);
51783 if (!SWIG_IsOK(ecode4)) {
51784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51785 }
51786 arg4 = static_cast< int >(val4);
51787 }
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51802 PyObject *resultobj = 0;
51803 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51804 size_t arg2 ;
51805 int arg3 = (int) 0 ;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 size_t val2 ;
51809 int ecode2 = 0 ;
51810 int val3 ;
51811 int ecode3 = 0 ;
51812 PyObject * obj0 = 0 ;
51813 PyObject * obj1 = 0 ;
51814 PyObject * obj2 = 0 ;
51815 char * kwnames[] = {
51816 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51817 };
51818
51819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51821 if (!SWIG_IsOK(res1)) {
51822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51823 }
51824 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51825 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51826 if (!SWIG_IsOK(ecode2)) {
51827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51828 }
51829 arg2 = static_cast< size_t >(val2);
51830 if (obj2) {
51831 ecode3 = SWIG_AsVal_int(obj2, &val3);
51832 if (!SWIG_IsOK(ecode3)) {
51833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51834 }
51835 arg3 = static_cast< int >(val3);
51836 }
51837 {
51838 PyThreadState* __tstate = wxPyBeginAllowThreads();
51839 (arg1)->AddGrowableRow(arg2,arg3);
51840 wxPyEndAllowThreads(__tstate);
51841 if (PyErr_Occurred()) SWIG_fail;
51842 }
51843 resultobj = SWIG_Py_Void();
51844 return resultobj;
51845 fail:
51846 return NULL;
51847 }
51848
51849
51850 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51851 PyObject *resultobj = 0;
51852 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51853 size_t arg2 ;
51854 void *argp1 = 0 ;
51855 int res1 = 0 ;
51856 size_t val2 ;
51857 int ecode2 = 0 ;
51858 PyObject * obj0 = 0 ;
51859 PyObject * obj1 = 0 ;
51860 char * kwnames[] = {
51861 (char *) "self",(char *) "idx", NULL
51862 };
51863
51864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51866 if (!SWIG_IsOK(res1)) {
51867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51868 }
51869 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51870 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51871 if (!SWIG_IsOK(ecode2)) {
51872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51873 }
51874 arg2 = static_cast< size_t >(val2);
51875 {
51876 PyThreadState* __tstate = wxPyBeginAllowThreads();
51877 (arg1)->RemoveGrowableRow(arg2);
51878 wxPyEndAllowThreads(__tstate);
51879 if (PyErr_Occurred()) SWIG_fail;
51880 }
51881 resultobj = SWIG_Py_Void();
51882 return resultobj;
51883 fail:
51884 return NULL;
51885 }
51886
51887
51888 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51889 PyObject *resultobj = 0;
51890 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51891 size_t arg2 ;
51892 int arg3 = (int) 0 ;
51893 void *argp1 = 0 ;
51894 int res1 = 0 ;
51895 size_t val2 ;
51896 int ecode2 = 0 ;
51897 int val3 ;
51898 int ecode3 = 0 ;
51899 PyObject * obj0 = 0 ;
51900 PyObject * obj1 = 0 ;
51901 PyObject * obj2 = 0 ;
51902 char * kwnames[] = {
51903 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51904 };
51905
51906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51908 if (!SWIG_IsOK(res1)) {
51909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51910 }
51911 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51913 if (!SWIG_IsOK(ecode2)) {
51914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51915 }
51916 arg2 = static_cast< size_t >(val2);
51917 if (obj2) {
51918 ecode3 = SWIG_AsVal_int(obj2, &val3);
51919 if (!SWIG_IsOK(ecode3)) {
51920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51921 }
51922 arg3 = static_cast< int >(val3);
51923 }
51924 {
51925 PyThreadState* __tstate = wxPyBeginAllowThreads();
51926 (arg1)->AddGrowableCol(arg2,arg3);
51927 wxPyEndAllowThreads(__tstate);
51928 if (PyErr_Occurred()) SWIG_fail;
51929 }
51930 resultobj = SWIG_Py_Void();
51931 return resultobj;
51932 fail:
51933 return NULL;
51934 }
51935
51936
51937 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51938 PyObject *resultobj = 0;
51939 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51940 size_t arg2 ;
51941 void *argp1 = 0 ;
51942 int res1 = 0 ;
51943 size_t val2 ;
51944 int ecode2 = 0 ;
51945 PyObject * obj0 = 0 ;
51946 PyObject * obj1 = 0 ;
51947 char * kwnames[] = {
51948 (char *) "self",(char *) "idx", NULL
51949 };
51950
51951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51953 if (!SWIG_IsOK(res1)) {
51954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51955 }
51956 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51957 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51958 if (!SWIG_IsOK(ecode2)) {
51959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51960 }
51961 arg2 = static_cast< size_t >(val2);
51962 {
51963 PyThreadState* __tstate = wxPyBeginAllowThreads();
51964 (arg1)->RemoveGrowableCol(arg2);
51965 wxPyEndAllowThreads(__tstate);
51966 if (PyErr_Occurred()) SWIG_fail;
51967 }
51968 resultobj = SWIG_Py_Void();
51969 return resultobj;
51970 fail:
51971 return NULL;
51972 }
51973
51974
51975 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51976 PyObject *resultobj = 0;
51977 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51978 int arg2 ;
51979 void *argp1 = 0 ;
51980 int res1 = 0 ;
51981 int val2 ;
51982 int ecode2 = 0 ;
51983 PyObject * obj0 = 0 ;
51984 PyObject * obj1 = 0 ;
51985 char * kwnames[] = {
51986 (char *) "self",(char *) "direction", NULL
51987 };
51988
51989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51991 if (!SWIG_IsOK(res1)) {
51992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51993 }
51994 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51995 ecode2 = SWIG_AsVal_int(obj1, &val2);
51996 if (!SWIG_IsOK(ecode2)) {
51997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51998 }
51999 arg2 = static_cast< int >(val2);
52000 {
52001 PyThreadState* __tstate = wxPyBeginAllowThreads();
52002 (arg1)->SetFlexibleDirection(arg2);
52003 wxPyEndAllowThreads(__tstate);
52004 if (PyErr_Occurred()) SWIG_fail;
52005 }
52006 resultobj = SWIG_Py_Void();
52007 return resultobj;
52008 fail:
52009 return NULL;
52010 }
52011
52012
52013 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52014 PyObject *resultobj = 0;
52015 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52016 int result;
52017 void *argp1 = 0 ;
52018 int res1 = 0 ;
52019 PyObject *swig_obj[1] ;
52020
52021 if (!args) SWIG_fail;
52022 swig_obj[0] = args;
52023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52024 if (!SWIG_IsOK(res1)) {
52025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52026 }
52027 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52028 {
52029 PyThreadState* __tstate = wxPyBeginAllowThreads();
52030 result = (int)(arg1)->GetFlexibleDirection();
52031 wxPyEndAllowThreads(__tstate);
52032 if (PyErr_Occurred()) SWIG_fail;
52033 }
52034 resultobj = SWIG_From_int(static_cast< int >(result));
52035 return resultobj;
52036 fail:
52037 return NULL;
52038 }
52039
52040
52041 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52042 PyObject *resultobj = 0;
52043 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52044 wxFlexSizerGrowMode arg2 ;
52045 void *argp1 = 0 ;
52046 int res1 = 0 ;
52047 int val2 ;
52048 int ecode2 = 0 ;
52049 PyObject * obj0 = 0 ;
52050 PyObject * obj1 = 0 ;
52051 char * kwnames[] = {
52052 (char *) "self",(char *) "mode", NULL
52053 };
52054
52055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52057 if (!SWIG_IsOK(res1)) {
52058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52059 }
52060 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52061 ecode2 = SWIG_AsVal_int(obj1, &val2);
52062 if (!SWIG_IsOK(ecode2)) {
52063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52064 }
52065 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52066 {
52067 PyThreadState* __tstate = wxPyBeginAllowThreads();
52068 (arg1)->SetNonFlexibleGrowMode(arg2);
52069 wxPyEndAllowThreads(__tstate);
52070 if (PyErr_Occurred()) SWIG_fail;
52071 }
52072 resultobj = SWIG_Py_Void();
52073 return resultobj;
52074 fail:
52075 return NULL;
52076 }
52077
52078
52079 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52080 PyObject *resultobj = 0;
52081 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52082 wxFlexSizerGrowMode result;
52083 void *argp1 = 0 ;
52084 int res1 = 0 ;
52085 PyObject *swig_obj[1] ;
52086
52087 if (!args) SWIG_fail;
52088 swig_obj[0] = args;
52089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52090 if (!SWIG_IsOK(res1)) {
52091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52092 }
52093 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52094 {
52095 PyThreadState* __tstate = wxPyBeginAllowThreads();
52096 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52097 wxPyEndAllowThreads(__tstate);
52098 if (PyErr_Occurred()) SWIG_fail;
52099 }
52100 resultobj = SWIG_From_int(static_cast< int >(result));
52101 return resultobj;
52102 fail:
52103 return NULL;
52104 }
52105
52106
52107 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52108 PyObject *resultobj = 0;
52109 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52110 wxArrayInt *result = 0 ;
52111 void *argp1 = 0 ;
52112 int res1 = 0 ;
52113 PyObject *swig_obj[1] ;
52114
52115 if (!args) SWIG_fail;
52116 swig_obj[0] = args;
52117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52118 if (!SWIG_IsOK(res1)) {
52119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52120 }
52121 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52122 {
52123 PyThreadState* __tstate = wxPyBeginAllowThreads();
52124 {
52125 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52126 result = (wxArrayInt *) &_result_ref;
52127 }
52128 wxPyEndAllowThreads(__tstate);
52129 if (PyErr_Occurred()) SWIG_fail;
52130 }
52131 {
52132 resultobj = wxArrayInt2PyList_helper(*result);
52133 }
52134 return resultobj;
52135 fail:
52136 return NULL;
52137 }
52138
52139
52140 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52141 PyObject *resultobj = 0;
52142 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52143 wxArrayInt *result = 0 ;
52144 void *argp1 = 0 ;
52145 int res1 = 0 ;
52146 PyObject *swig_obj[1] ;
52147
52148 if (!args) SWIG_fail;
52149 swig_obj[0] = args;
52150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52153 }
52154 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52155 {
52156 PyThreadState* __tstate = wxPyBeginAllowThreads();
52157 {
52158 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52159 result = (wxArrayInt *) &_result_ref;
52160 }
52161 wxPyEndAllowThreads(__tstate);
52162 if (PyErr_Occurred()) SWIG_fail;
52163 }
52164 {
52165 resultobj = wxArrayInt2PyList_helper(*result);
52166 }
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *obj;
52175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52176 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52177 return SWIG_Py_Void();
52178 }
52179
52180 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52181 return SWIG_Python_InitShadowInstance(args);
52182 }
52183
52184 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52185 PyObject *resultobj = 0;
52186 wxStdDialogButtonSizer *result = 0 ;
52187
52188 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52189 {
52190 PyThreadState* __tstate = wxPyBeginAllowThreads();
52191 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52192 wxPyEndAllowThreads(__tstate);
52193 if (PyErr_Occurred()) SWIG_fail;
52194 }
52195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52196 return resultobj;
52197 fail:
52198 return NULL;
52199 }
52200
52201
52202 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52203 PyObject *resultobj = 0;
52204 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52205 wxButton *arg2 = (wxButton *) 0 ;
52206 void *argp1 = 0 ;
52207 int res1 = 0 ;
52208 void *argp2 = 0 ;
52209 int res2 = 0 ;
52210 PyObject * obj0 = 0 ;
52211 PyObject * obj1 = 0 ;
52212 char * kwnames[] = {
52213 (char *) "self",(char *) "button", NULL
52214 };
52215
52216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52218 if (!SWIG_IsOK(res1)) {
52219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52220 }
52221 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52223 if (!SWIG_IsOK(res2)) {
52224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52225 }
52226 arg2 = reinterpret_cast< wxButton * >(argp2);
52227 {
52228 PyThreadState* __tstate = wxPyBeginAllowThreads();
52229 (arg1)->AddButton(arg2);
52230 wxPyEndAllowThreads(__tstate);
52231 if (PyErr_Occurred()) SWIG_fail;
52232 }
52233 resultobj = SWIG_Py_Void();
52234 return resultobj;
52235 fail:
52236 return NULL;
52237 }
52238
52239
52240 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52241 PyObject *resultobj = 0;
52242 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 PyObject *swig_obj[1] ;
52246
52247 if (!args) SWIG_fail;
52248 swig_obj[0] = args;
52249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52252 }
52253 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52254 {
52255 PyThreadState* __tstate = wxPyBeginAllowThreads();
52256 (arg1)->Realize();
52257 wxPyEndAllowThreads(__tstate);
52258 if (PyErr_Occurred()) SWIG_fail;
52259 }
52260 resultobj = SWIG_Py_Void();
52261 return resultobj;
52262 fail:
52263 return NULL;
52264 }
52265
52266
52267 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52268 PyObject *resultobj = 0;
52269 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52270 wxButton *arg2 = (wxButton *) 0 ;
52271 void *argp1 = 0 ;
52272 int res1 = 0 ;
52273 void *argp2 = 0 ;
52274 int res2 = 0 ;
52275 PyObject * obj0 = 0 ;
52276 PyObject * obj1 = 0 ;
52277 char * kwnames[] = {
52278 (char *) "self",(char *) "button", NULL
52279 };
52280
52281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52283 if (!SWIG_IsOK(res1)) {
52284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52285 }
52286 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52288 if (!SWIG_IsOK(res2)) {
52289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52290 }
52291 arg2 = reinterpret_cast< wxButton * >(argp2);
52292 {
52293 PyThreadState* __tstate = wxPyBeginAllowThreads();
52294 (arg1)->SetAffirmativeButton(arg2);
52295 wxPyEndAllowThreads(__tstate);
52296 if (PyErr_Occurred()) SWIG_fail;
52297 }
52298 resultobj = SWIG_Py_Void();
52299 return resultobj;
52300 fail:
52301 return NULL;
52302 }
52303
52304
52305 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52306 PyObject *resultobj = 0;
52307 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52308 wxButton *arg2 = (wxButton *) 0 ;
52309 void *argp1 = 0 ;
52310 int res1 = 0 ;
52311 void *argp2 = 0 ;
52312 int res2 = 0 ;
52313 PyObject * obj0 = 0 ;
52314 PyObject * obj1 = 0 ;
52315 char * kwnames[] = {
52316 (char *) "self",(char *) "button", NULL
52317 };
52318
52319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52323 }
52324 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52326 if (!SWIG_IsOK(res2)) {
52327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52328 }
52329 arg2 = reinterpret_cast< wxButton * >(argp2);
52330 {
52331 PyThreadState* __tstate = wxPyBeginAllowThreads();
52332 (arg1)->SetNegativeButton(arg2);
52333 wxPyEndAllowThreads(__tstate);
52334 if (PyErr_Occurred()) SWIG_fail;
52335 }
52336 resultobj = SWIG_Py_Void();
52337 return resultobj;
52338 fail:
52339 return NULL;
52340 }
52341
52342
52343 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52344 PyObject *resultobj = 0;
52345 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52346 wxButton *arg2 = (wxButton *) 0 ;
52347 void *argp1 = 0 ;
52348 int res1 = 0 ;
52349 void *argp2 = 0 ;
52350 int res2 = 0 ;
52351 PyObject * obj0 = 0 ;
52352 PyObject * obj1 = 0 ;
52353 char * kwnames[] = {
52354 (char *) "self",(char *) "button", NULL
52355 };
52356
52357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52359 if (!SWIG_IsOK(res1)) {
52360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52361 }
52362 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52364 if (!SWIG_IsOK(res2)) {
52365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52366 }
52367 arg2 = reinterpret_cast< wxButton * >(argp2);
52368 {
52369 PyThreadState* __tstate = wxPyBeginAllowThreads();
52370 (arg1)->SetCancelButton(arg2);
52371 wxPyEndAllowThreads(__tstate);
52372 if (PyErr_Occurred()) SWIG_fail;
52373 }
52374 resultobj = SWIG_Py_Void();
52375 return resultobj;
52376 fail:
52377 return NULL;
52378 }
52379
52380
52381 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52382 PyObject *resultobj = 0;
52383 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52384 wxButton *result = 0 ;
52385 void *argp1 = 0 ;
52386 int res1 = 0 ;
52387 PyObject *swig_obj[1] ;
52388
52389 if (!args) SWIG_fail;
52390 swig_obj[0] = args;
52391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52392 if (!SWIG_IsOK(res1)) {
52393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52394 }
52395 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52396 {
52397 PyThreadState* __tstate = wxPyBeginAllowThreads();
52398 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52399 wxPyEndAllowThreads(__tstate);
52400 if (PyErr_Occurred()) SWIG_fail;
52401 }
52402 {
52403 resultobj = wxPyMake_wxObject(result, (bool)0);
52404 }
52405 return resultobj;
52406 fail:
52407 return NULL;
52408 }
52409
52410
52411 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52412 PyObject *resultobj = 0;
52413 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52414 wxButton *result = 0 ;
52415 void *argp1 = 0 ;
52416 int res1 = 0 ;
52417 PyObject *swig_obj[1] ;
52418
52419 if (!args) SWIG_fail;
52420 swig_obj[0] = args;
52421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52422 if (!SWIG_IsOK(res1)) {
52423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52424 }
52425 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52426 {
52427 PyThreadState* __tstate = wxPyBeginAllowThreads();
52428 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52429 wxPyEndAllowThreads(__tstate);
52430 if (PyErr_Occurred()) SWIG_fail;
52431 }
52432 {
52433 resultobj = wxPyMake_wxObject(result, (bool)0);
52434 }
52435 return resultobj;
52436 fail:
52437 return NULL;
52438 }
52439
52440
52441 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52442 PyObject *resultobj = 0;
52443 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52444 wxButton *result = 0 ;
52445 void *argp1 = 0 ;
52446 int res1 = 0 ;
52447 PyObject *swig_obj[1] ;
52448
52449 if (!args) SWIG_fail;
52450 swig_obj[0] = args;
52451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52452 if (!SWIG_IsOK(res1)) {
52453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52454 }
52455 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52456 {
52457 PyThreadState* __tstate = wxPyBeginAllowThreads();
52458 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52459 wxPyEndAllowThreads(__tstate);
52460 if (PyErr_Occurred()) SWIG_fail;
52461 }
52462 {
52463 resultobj = wxPyMake_wxObject(result, (bool)0);
52464 }
52465 return resultobj;
52466 fail:
52467 return NULL;
52468 }
52469
52470
52471 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52472 PyObject *resultobj = 0;
52473 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52474 wxButton *result = 0 ;
52475 void *argp1 = 0 ;
52476 int res1 = 0 ;
52477 PyObject *swig_obj[1] ;
52478
52479 if (!args) SWIG_fail;
52480 swig_obj[0] = args;
52481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52482 if (!SWIG_IsOK(res1)) {
52483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52484 }
52485 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52486 {
52487 PyThreadState* __tstate = wxPyBeginAllowThreads();
52488 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52489 wxPyEndAllowThreads(__tstate);
52490 if (PyErr_Occurred()) SWIG_fail;
52491 }
52492 {
52493 resultobj = wxPyMake_wxObject(result, (bool)0);
52494 }
52495 return resultobj;
52496 fail:
52497 return NULL;
52498 }
52499
52500
52501 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52502 PyObject *resultobj = 0;
52503 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52504 wxButton *result = 0 ;
52505 void *argp1 = 0 ;
52506 int res1 = 0 ;
52507 PyObject *swig_obj[1] ;
52508
52509 if (!args) SWIG_fail;
52510 swig_obj[0] = args;
52511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52512 if (!SWIG_IsOK(res1)) {
52513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52514 }
52515 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52516 {
52517 PyThreadState* __tstate = wxPyBeginAllowThreads();
52518 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52519 wxPyEndAllowThreads(__tstate);
52520 if (PyErr_Occurred()) SWIG_fail;
52521 }
52522 {
52523 resultobj = wxPyMake_wxObject(result, (bool)0);
52524 }
52525 return resultobj;
52526 fail:
52527 return NULL;
52528 }
52529
52530
52531 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52532 PyObject *obj;
52533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52534 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52535 return SWIG_Py_Void();
52536 }
52537
52538 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52539 return SWIG_Python_InitShadowInstance(args);
52540 }
52541
52542 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52543 PyObject *resultobj = 0;
52544 int arg1 = (int) 0 ;
52545 int arg2 = (int) 0 ;
52546 wxGBPosition *result = 0 ;
52547 int val1 ;
52548 int ecode1 = 0 ;
52549 int val2 ;
52550 int ecode2 = 0 ;
52551 PyObject * obj0 = 0 ;
52552 PyObject * obj1 = 0 ;
52553 char * kwnames[] = {
52554 (char *) "row",(char *) "col", NULL
52555 };
52556
52557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52558 if (obj0) {
52559 ecode1 = SWIG_AsVal_int(obj0, &val1);
52560 if (!SWIG_IsOK(ecode1)) {
52561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52562 }
52563 arg1 = static_cast< int >(val1);
52564 }
52565 if (obj1) {
52566 ecode2 = SWIG_AsVal_int(obj1, &val2);
52567 if (!SWIG_IsOK(ecode2)) {
52568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52569 }
52570 arg2 = static_cast< int >(val2);
52571 }
52572 {
52573 PyThreadState* __tstate = wxPyBeginAllowThreads();
52574 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52575 wxPyEndAllowThreads(__tstate);
52576 if (PyErr_Occurred()) SWIG_fail;
52577 }
52578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52579 return resultobj;
52580 fail:
52581 return NULL;
52582 }
52583
52584
52585 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52586 PyObject *resultobj = 0;
52587 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52588 void *argp1 = 0 ;
52589 int res1 = 0 ;
52590 PyObject *swig_obj[1] ;
52591
52592 if (!args) SWIG_fail;
52593 swig_obj[0] = args;
52594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52595 if (!SWIG_IsOK(res1)) {
52596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52597 }
52598 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52599 {
52600 PyThreadState* __tstate = wxPyBeginAllowThreads();
52601 delete arg1;
52602
52603 wxPyEndAllowThreads(__tstate);
52604 if (PyErr_Occurred()) SWIG_fail;
52605 }
52606 resultobj = SWIG_Py_Void();
52607 return resultobj;
52608 fail:
52609 return NULL;
52610 }
52611
52612
52613 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52614 PyObject *resultobj = 0;
52615 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52616 int result;
52617 void *argp1 = 0 ;
52618 int res1 = 0 ;
52619 PyObject *swig_obj[1] ;
52620
52621 if (!args) SWIG_fail;
52622 swig_obj[0] = args;
52623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52624 if (!SWIG_IsOK(res1)) {
52625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52626 }
52627 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52628 {
52629 PyThreadState* __tstate = wxPyBeginAllowThreads();
52630 result = (int)((wxGBPosition const *)arg1)->GetRow();
52631 wxPyEndAllowThreads(__tstate);
52632 if (PyErr_Occurred()) SWIG_fail;
52633 }
52634 resultobj = SWIG_From_int(static_cast< int >(result));
52635 return resultobj;
52636 fail:
52637 return NULL;
52638 }
52639
52640
52641 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52642 PyObject *resultobj = 0;
52643 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52644 int result;
52645 void *argp1 = 0 ;
52646 int res1 = 0 ;
52647 PyObject *swig_obj[1] ;
52648
52649 if (!args) SWIG_fail;
52650 swig_obj[0] = args;
52651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52652 if (!SWIG_IsOK(res1)) {
52653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52654 }
52655 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52656 {
52657 PyThreadState* __tstate = wxPyBeginAllowThreads();
52658 result = (int)((wxGBPosition const *)arg1)->GetCol();
52659 wxPyEndAllowThreads(__tstate);
52660 if (PyErr_Occurred()) SWIG_fail;
52661 }
52662 resultobj = SWIG_From_int(static_cast< int >(result));
52663 return resultobj;
52664 fail:
52665 return NULL;
52666 }
52667
52668
52669 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52670 PyObject *resultobj = 0;
52671 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52672 int arg2 ;
52673 void *argp1 = 0 ;
52674 int res1 = 0 ;
52675 int val2 ;
52676 int ecode2 = 0 ;
52677 PyObject * obj0 = 0 ;
52678 PyObject * obj1 = 0 ;
52679 char * kwnames[] = {
52680 (char *) "self",(char *) "row", NULL
52681 };
52682
52683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52685 if (!SWIG_IsOK(res1)) {
52686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52687 }
52688 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52689 ecode2 = SWIG_AsVal_int(obj1, &val2);
52690 if (!SWIG_IsOK(ecode2)) {
52691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52692 }
52693 arg2 = static_cast< int >(val2);
52694 {
52695 PyThreadState* __tstate = wxPyBeginAllowThreads();
52696 (arg1)->SetRow(arg2);
52697 wxPyEndAllowThreads(__tstate);
52698 if (PyErr_Occurred()) SWIG_fail;
52699 }
52700 resultobj = SWIG_Py_Void();
52701 return resultobj;
52702 fail:
52703 return NULL;
52704 }
52705
52706
52707 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52708 PyObject *resultobj = 0;
52709 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52710 int arg2 ;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 int val2 ;
52714 int ecode2 = 0 ;
52715 PyObject * obj0 = 0 ;
52716 PyObject * obj1 = 0 ;
52717 char * kwnames[] = {
52718 (char *) "self",(char *) "col", NULL
52719 };
52720
52721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52723 if (!SWIG_IsOK(res1)) {
52724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52725 }
52726 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52727 ecode2 = SWIG_AsVal_int(obj1, &val2);
52728 if (!SWIG_IsOK(ecode2)) {
52729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52730 }
52731 arg2 = static_cast< int >(val2);
52732 {
52733 PyThreadState* __tstate = wxPyBeginAllowThreads();
52734 (arg1)->SetCol(arg2);
52735 wxPyEndAllowThreads(__tstate);
52736 if (PyErr_Occurred()) SWIG_fail;
52737 }
52738 resultobj = SWIG_Py_Void();
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52746 PyObject *resultobj = 0;
52747 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52748 PyObject *arg2 = (PyObject *) 0 ;
52749 bool result;
52750 void *argp1 = 0 ;
52751 int res1 = 0 ;
52752 PyObject * obj0 = 0 ;
52753 PyObject * obj1 = 0 ;
52754 char * kwnames[] = {
52755 (char *) "self",(char *) "other", NULL
52756 };
52757
52758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52760 if (!SWIG_IsOK(res1)) {
52761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52762 }
52763 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52764 arg2 = obj1;
52765 {
52766 result = (bool)wxGBPosition___eq__(arg1,arg2);
52767 if (PyErr_Occurred()) SWIG_fail;
52768 }
52769 {
52770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52771 }
52772 return resultobj;
52773 fail:
52774 return NULL;
52775 }
52776
52777
52778 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52779 PyObject *resultobj = 0;
52780 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52781 PyObject *arg2 = (PyObject *) 0 ;
52782 bool result;
52783 void *argp1 = 0 ;
52784 int res1 = 0 ;
52785 PyObject * obj0 = 0 ;
52786 PyObject * obj1 = 0 ;
52787 char * kwnames[] = {
52788 (char *) "self",(char *) "other", NULL
52789 };
52790
52791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52793 if (!SWIG_IsOK(res1)) {
52794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52795 }
52796 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52797 arg2 = obj1;
52798 {
52799 result = (bool)wxGBPosition___ne__(arg1,arg2);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 {
52803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52804 }
52805 return resultobj;
52806 fail:
52807 return NULL;
52808 }
52809
52810
52811 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52812 PyObject *resultobj = 0;
52813 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52814 int arg2 = (int) 0 ;
52815 int arg3 = (int) 0 ;
52816 void *argp1 = 0 ;
52817 int res1 = 0 ;
52818 int val2 ;
52819 int ecode2 = 0 ;
52820 int val3 ;
52821 int ecode3 = 0 ;
52822 PyObject * obj0 = 0 ;
52823 PyObject * obj1 = 0 ;
52824 PyObject * obj2 = 0 ;
52825 char * kwnames[] = {
52826 (char *) "self",(char *) "row",(char *) "col", NULL
52827 };
52828
52829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52831 if (!SWIG_IsOK(res1)) {
52832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52833 }
52834 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52835 if (obj1) {
52836 ecode2 = SWIG_AsVal_int(obj1, &val2);
52837 if (!SWIG_IsOK(ecode2)) {
52838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52839 }
52840 arg2 = static_cast< int >(val2);
52841 }
52842 if (obj2) {
52843 ecode3 = SWIG_AsVal_int(obj2, &val3);
52844 if (!SWIG_IsOK(ecode3)) {
52845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52846 }
52847 arg3 = static_cast< int >(val3);
52848 }
52849 {
52850 PyThreadState* __tstate = wxPyBeginAllowThreads();
52851 wxGBPosition_Set(arg1,arg2,arg3);
52852 wxPyEndAllowThreads(__tstate);
52853 if (PyErr_Occurred()) SWIG_fail;
52854 }
52855 resultobj = SWIG_Py_Void();
52856 return resultobj;
52857 fail:
52858 return NULL;
52859 }
52860
52861
52862 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52863 PyObject *resultobj = 0;
52864 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52865 PyObject *result = 0 ;
52866 void *argp1 = 0 ;
52867 int res1 = 0 ;
52868 PyObject *swig_obj[1] ;
52869
52870 if (!args) SWIG_fail;
52871 swig_obj[0] = args;
52872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52873 if (!SWIG_IsOK(res1)) {
52874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52875 }
52876 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52877 {
52878 PyThreadState* __tstate = wxPyBeginAllowThreads();
52879 result = (PyObject *)wxGBPosition_Get(arg1);
52880 wxPyEndAllowThreads(__tstate);
52881 if (PyErr_Occurred()) SWIG_fail;
52882 }
52883 resultobj = result;
52884 return resultobj;
52885 fail:
52886 return NULL;
52887 }
52888
52889
52890 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52891 PyObject *obj;
52892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52893 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52894 return SWIG_Py_Void();
52895 }
52896
52897 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52898 return SWIG_Python_InitShadowInstance(args);
52899 }
52900
52901 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52902 PyObject *resultobj = 0;
52903 int arg1 = (int) 1 ;
52904 int arg2 = (int) 1 ;
52905 wxGBSpan *result = 0 ;
52906 int val1 ;
52907 int ecode1 = 0 ;
52908 int val2 ;
52909 int ecode2 = 0 ;
52910 PyObject * obj0 = 0 ;
52911 PyObject * obj1 = 0 ;
52912 char * kwnames[] = {
52913 (char *) "rowspan",(char *) "colspan", NULL
52914 };
52915
52916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52917 if (obj0) {
52918 ecode1 = SWIG_AsVal_int(obj0, &val1);
52919 if (!SWIG_IsOK(ecode1)) {
52920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52921 }
52922 arg1 = static_cast< int >(val1);
52923 }
52924 if (obj1) {
52925 ecode2 = SWIG_AsVal_int(obj1, &val2);
52926 if (!SWIG_IsOK(ecode2)) {
52927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52928 }
52929 arg2 = static_cast< int >(val2);
52930 }
52931 {
52932 PyThreadState* __tstate = wxPyBeginAllowThreads();
52933 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52934 wxPyEndAllowThreads(__tstate);
52935 if (PyErr_Occurred()) SWIG_fail;
52936 }
52937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52938 return resultobj;
52939 fail:
52940 return NULL;
52941 }
52942
52943
52944 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52945 PyObject *resultobj = 0;
52946 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52947 void *argp1 = 0 ;
52948 int res1 = 0 ;
52949 PyObject *swig_obj[1] ;
52950
52951 if (!args) SWIG_fail;
52952 swig_obj[0] = args;
52953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52954 if (!SWIG_IsOK(res1)) {
52955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52956 }
52957 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52958 {
52959 PyThreadState* __tstate = wxPyBeginAllowThreads();
52960 delete arg1;
52961
52962 wxPyEndAllowThreads(__tstate);
52963 if (PyErr_Occurred()) SWIG_fail;
52964 }
52965 resultobj = SWIG_Py_Void();
52966 return resultobj;
52967 fail:
52968 return NULL;
52969 }
52970
52971
52972 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52973 PyObject *resultobj = 0;
52974 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52975 int result;
52976 void *argp1 = 0 ;
52977 int res1 = 0 ;
52978 PyObject *swig_obj[1] ;
52979
52980 if (!args) SWIG_fail;
52981 swig_obj[0] = args;
52982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52983 if (!SWIG_IsOK(res1)) {
52984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52985 }
52986 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52987 {
52988 PyThreadState* __tstate = wxPyBeginAllowThreads();
52989 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52990 wxPyEndAllowThreads(__tstate);
52991 if (PyErr_Occurred()) SWIG_fail;
52992 }
52993 resultobj = SWIG_From_int(static_cast< int >(result));
52994 return resultobj;
52995 fail:
52996 return NULL;
52997 }
52998
52999
53000 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53001 PyObject *resultobj = 0;
53002 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53003 int result;
53004 void *argp1 = 0 ;
53005 int res1 = 0 ;
53006 PyObject *swig_obj[1] ;
53007
53008 if (!args) SWIG_fail;
53009 swig_obj[0] = args;
53010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53011 if (!SWIG_IsOK(res1)) {
53012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53013 }
53014 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53015 {
53016 PyThreadState* __tstate = wxPyBeginAllowThreads();
53017 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53018 wxPyEndAllowThreads(__tstate);
53019 if (PyErr_Occurred()) SWIG_fail;
53020 }
53021 resultobj = SWIG_From_int(static_cast< int >(result));
53022 return resultobj;
53023 fail:
53024 return NULL;
53025 }
53026
53027
53028 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53029 PyObject *resultobj = 0;
53030 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53031 int arg2 ;
53032 void *argp1 = 0 ;
53033 int res1 = 0 ;
53034 int val2 ;
53035 int ecode2 = 0 ;
53036 PyObject * obj0 = 0 ;
53037 PyObject * obj1 = 0 ;
53038 char * kwnames[] = {
53039 (char *) "self",(char *) "rowspan", NULL
53040 };
53041
53042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53044 if (!SWIG_IsOK(res1)) {
53045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53046 }
53047 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53048 ecode2 = SWIG_AsVal_int(obj1, &val2);
53049 if (!SWIG_IsOK(ecode2)) {
53050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53051 }
53052 arg2 = static_cast< int >(val2);
53053 {
53054 PyThreadState* __tstate = wxPyBeginAllowThreads();
53055 (arg1)->SetRowspan(arg2);
53056 wxPyEndAllowThreads(__tstate);
53057 if (PyErr_Occurred()) SWIG_fail;
53058 }
53059 resultobj = SWIG_Py_Void();
53060 return resultobj;
53061 fail:
53062 return NULL;
53063 }
53064
53065
53066 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53067 PyObject *resultobj = 0;
53068 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53069 int arg2 ;
53070 void *argp1 = 0 ;
53071 int res1 = 0 ;
53072 int val2 ;
53073 int ecode2 = 0 ;
53074 PyObject * obj0 = 0 ;
53075 PyObject * obj1 = 0 ;
53076 char * kwnames[] = {
53077 (char *) "self",(char *) "colspan", NULL
53078 };
53079
53080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53082 if (!SWIG_IsOK(res1)) {
53083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53084 }
53085 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53086 ecode2 = SWIG_AsVal_int(obj1, &val2);
53087 if (!SWIG_IsOK(ecode2)) {
53088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53089 }
53090 arg2 = static_cast< int >(val2);
53091 {
53092 PyThreadState* __tstate = wxPyBeginAllowThreads();
53093 (arg1)->SetColspan(arg2);
53094 wxPyEndAllowThreads(__tstate);
53095 if (PyErr_Occurred()) SWIG_fail;
53096 }
53097 resultobj = SWIG_Py_Void();
53098 return resultobj;
53099 fail:
53100 return NULL;
53101 }
53102
53103
53104 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53105 PyObject *resultobj = 0;
53106 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53107 PyObject *arg2 = (PyObject *) 0 ;
53108 bool result;
53109 void *argp1 = 0 ;
53110 int res1 = 0 ;
53111 PyObject * obj0 = 0 ;
53112 PyObject * obj1 = 0 ;
53113 char * kwnames[] = {
53114 (char *) "self",(char *) "other", NULL
53115 };
53116
53117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53119 if (!SWIG_IsOK(res1)) {
53120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53121 }
53122 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53123 arg2 = obj1;
53124 {
53125 result = (bool)wxGBSpan___eq__(arg1,arg2);
53126 if (PyErr_Occurred()) SWIG_fail;
53127 }
53128 {
53129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53130 }
53131 return resultobj;
53132 fail:
53133 return NULL;
53134 }
53135
53136
53137 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53138 PyObject *resultobj = 0;
53139 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53140 PyObject *arg2 = (PyObject *) 0 ;
53141 bool result;
53142 void *argp1 = 0 ;
53143 int res1 = 0 ;
53144 PyObject * obj0 = 0 ;
53145 PyObject * obj1 = 0 ;
53146 char * kwnames[] = {
53147 (char *) "self",(char *) "other", NULL
53148 };
53149
53150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53152 if (!SWIG_IsOK(res1)) {
53153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53154 }
53155 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53156 arg2 = obj1;
53157 {
53158 result = (bool)wxGBSpan___ne__(arg1,arg2);
53159 if (PyErr_Occurred()) SWIG_fail;
53160 }
53161 {
53162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53163 }
53164 return resultobj;
53165 fail:
53166 return NULL;
53167 }
53168
53169
53170 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53171 PyObject *resultobj = 0;
53172 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53173 int arg2 = (int) 1 ;
53174 int arg3 = (int) 1 ;
53175 void *argp1 = 0 ;
53176 int res1 = 0 ;
53177 int val2 ;
53178 int ecode2 = 0 ;
53179 int val3 ;
53180 int ecode3 = 0 ;
53181 PyObject * obj0 = 0 ;
53182 PyObject * obj1 = 0 ;
53183 PyObject * obj2 = 0 ;
53184 char * kwnames[] = {
53185 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53186 };
53187
53188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53190 if (!SWIG_IsOK(res1)) {
53191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53192 }
53193 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53194 if (obj1) {
53195 ecode2 = SWIG_AsVal_int(obj1, &val2);
53196 if (!SWIG_IsOK(ecode2)) {
53197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53198 }
53199 arg2 = static_cast< int >(val2);
53200 }
53201 if (obj2) {
53202 ecode3 = SWIG_AsVal_int(obj2, &val3);
53203 if (!SWIG_IsOK(ecode3)) {
53204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53205 }
53206 arg3 = static_cast< int >(val3);
53207 }
53208 {
53209 PyThreadState* __tstate = wxPyBeginAllowThreads();
53210 wxGBSpan_Set(arg1,arg2,arg3);
53211 wxPyEndAllowThreads(__tstate);
53212 if (PyErr_Occurred()) SWIG_fail;
53213 }
53214 resultobj = SWIG_Py_Void();
53215 return resultobj;
53216 fail:
53217 return NULL;
53218 }
53219
53220
53221 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53222 PyObject *resultobj = 0;
53223 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53224 PyObject *result = 0 ;
53225 void *argp1 = 0 ;
53226 int res1 = 0 ;
53227 PyObject *swig_obj[1] ;
53228
53229 if (!args) SWIG_fail;
53230 swig_obj[0] = args;
53231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53232 if (!SWIG_IsOK(res1)) {
53233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53234 }
53235 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53236 {
53237 PyThreadState* __tstate = wxPyBeginAllowThreads();
53238 result = (PyObject *)wxGBSpan_Get(arg1);
53239 wxPyEndAllowThreads(__tstate);
53240 if (PyErr_Occurred()) SWIG_fail;
53241 }
53242 resultobj = result;
53243 return resultobj;
53244 fail:
53245 return NULL;
53246 }
53247
53248
53249 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53250 PyObject *obj;
53251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53252 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53253 return SWIG_Py_Void();
53254 }
53255
53256 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53257 return SWIG_Python_InitShadowInstance(args);
53258 }
53259
53260 SWIGINTERN int DefaultSpan_set(PyObject *) {
53261 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53262 return 1;
53263 }
53264
53265
53266 SWIGINTERN PyObject *DefaultSpan_get(void) {
53267 PyObject *pyobj = 0;
53268
53269 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53270 return pyobj;
53271 }
53272
53273
53274 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53275 PyObject *resultobj = 0;
53276 wxGBSizerItem *result = 0 ;
53277
53278 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53279 {
53280 PyThreadState* __tstate = wxPyBeginAllowThreads();
53281 result = (wxGBSizerItem *)new wxGBSizerItem();
53282 wxPyEndAllowThreads(__tstate);
53283 if (PyErr_Occurred()) SWIG_fail;
53284 }
53285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53286 return resultobj;
53287 fail:
53288 return NULL;
53289 }
53290
53291
53292 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53293 PyObject *resultobj = 0;
53294 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53295 void *argp1 = 0 ;
53296 int res1 = 0 ;
53297 PyObject *swig_obj[1] ;
53298
53299 if (!args) SWIG_fail;
53300 swig_obj[0] = args;
53301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53302 if (!SWIG_IsOK(res1)) {
53303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53304 }
53305 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53306 {
53307 PyThreadState* __tstate = wxPyBeginAllowThreads();
53308 delete arg1;
53309
53310 wxPyEndAllowThreads(__tstate);
53311 if (PyErr_Occurred()) SWIG_fail;
53312 }
53313 resultobj = SWIG_Py_Void();
53314 return resultobj;
53315 fail:
53316 return NULL;
53317 }
53318
53319
53320 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53321 PyObject *resultobj = 0;
53322 wxWindow *arg1 = (wxWindow *) 0 ;
53323 wxGBPosition *arg2 = 0 ;
53324 wxGBSpan *arg3 = 0 ;
53325 int arg4 ;
53326 int arg5 ;
53327 PyObject *arg6 = (PyObject *) NULL ;
53328 wxGBSizerItem *result = 0 ;
53329 void *argp1 = 0 ;
53330 int res1 = 0 ;
53331 wxGBPosition temp2 ;
53332 wxGBSpan temp3 ;
53333 int val4 ;
53334 int ecode4 = 0 ;
53335 int val5 ;
53336 int ecode5 = 0 ;
53337 PyObject * obj0 = 0 ;
53338 PyObject * obj1 = 0 ;
53339 PyObject * obj2 = 0 ;
53340 PyObject * obj3 = 0 ;
53341 PyObject * obj4 = 0 ;
53342 PyObject * obj5 = 0 ;
53343 char * kwnames[] = {
53344 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53345 };
53346
53347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53349 if (!SWIG_IsOK(res1)) {
53350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53351 }
53352 arg1 = reinterpret_cast< wxWindow * >(argp1);
53353 {
53354 arg2 = &temp2;
53355 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53356 }
53357 {
53358 arg3 = &temp3;
53359 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53360 }
53361 ecode4 = SWIG_AsVal_int(obj3, &val4);
53362 if (!SWIG_IsOK(ecode4)) {
53363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53364 }
53365 arg4 = static_cast< int >(val4);
53366 ecode5 = SWIG_AsVal_int(obj4, &val5);
53367 if (!SWIG_IsOK(ecode5)) {
53368 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53369 }
53370 arg5 = static_cast< int >(val5);
53371 if (obj5) {
53372 arg6 = obj5;
53373 }
53374 {
53375 PyThreadState* __tstate = wxPyBeginAllowThreads();
53376 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53377 wxPyEndAllowThreads(__tstate);
53378 if (PyErr_Occurred()) SWIG_fail;
53379 }
53380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53381 return resultobj;
53382 fail:
53383 return NULL;
53384 }
53385
53386
53387 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53388 PyObject *resultobj = 0;
53389 wxSizer *arg1 = (wxSizer *) 0 ;
53390 wxGBPosition *arg2 = 0 ;
53391 wxGBSpan *arg3 = 0 ;
53392 int arg4 ;
53393 int arg5 ;
53394 PyObject *arg6 = (PyObject *) NULL ;
53395 wxGBSizerItem *result = 0 ;
53396 int res1 = 0 ;
53397 wxGBPosition temp2 ;
53398 wxGBSpan temp3 ;
53399 int val4 ;
53400 int ecode4 = 0 ;
53401 int val5 ;
53402 int ecode5 = 0 ;
53403 PyObject * obj0 = 0 ;
53404 PyObject * obj1 = 0 ;
53405 PyObject * obj2 = 0 ;
53406 PyObject * obj3 = 0 ;
53407 PyObject * obj4 = 0 ;
53408 PyObject * obj5 = 0 ;
53409 char * kwnames[] = {
53410 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53411 };
53412
53413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53414 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53415 if (!SWIG_IsOK(res1)) {
53416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53417 }
53418 {
53419 arg2 = &temp2;
53420 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53421 }
53422 {
53423 arg3 = &temp3;
53424 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53425 }
53426 ecode4 = SWIG_AsVal_int(obj3, &val4);
53427 if (!SWIG_IsOK(ecode4)) {
53428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53429 }
53430 arg4 = static_cast< int >(val4);
53431 ecode5 = SWIG_AsVal_int(obj4, &val5);
53432 if (!SWIG_IsOK(ecode5)) {
53433 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53434 }
53435 arg5 = static_cast< int >(val5);
53436 if (obj5) {
53437 arg6 = obj5;
53438 }
53439 {
53440 PyThreadState* __tstate = wxPyBeginAllowThreads();
53441 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53442 wxPyEndAllowThreads(__tstate);
53443 if (PyErr_Occurred()) SWIG_fail;
53444 }
53445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53446 return resultobj;
53447 fail:
53448 return NULL;
53449 }
53450
53451
53452 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53453 PyObject *resultobj = 0;
53454 int arg1 ;
53455 int arg2 ;
53456 wxGBPosition *arg3 = 0 ;
53457 wxGBSpan *arg4 = 0 ;
53458 int arg5 ;
53459 int arg6 ;
53460 PyObject *arg7 = (PyObject *) NULL ;
53461 wxGBSizerItem *result = 0 ;
53462 int val1 ;
53463 int ecode1 = 0 ;
53464 int val2 ;
53465 int ecode2 = 0 ;
53466 wxGBPosition temp3 ;
53467 wxGBSpan temp4 ;
53468 int val5 ;
53469 int ecode5 = 0 ;
53470 int val6 ;
53471 int ecode6 = 0 ;
53472 PyObject * obj0 = 0 ;
53473 PyObject * obj1 = 0 ;
53474 PyObject * obj2 = 0 ;
53475 PyObject * obj3 = 0 ;
53476 PyObject * obj4 = 0 ;
53477 PyObject * obj5 = 0 ;
53478 PyObject * obj6 = 0 ;
53479 char * kwnames[] = {
53480 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53481 };
53482
53483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53484 ecode1 = SWIG_AsVal_int(obj0, &val1);
53485 if (!SWIG_IsOK(ecode1)) {
53486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53487 }
53488 arg1 = static_cast< int >(val1);
53489 ecode2 = SWIG_AsVal_int(obj1, &val2);
53490 if (!SWIG_IsOK(ecode2)) {
53491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53492 }
53493 arg2 = static_cast< int >(val2);
53494 {
53495 arg3 = &temp3;
53496 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53497 }
53498 {
53499 arg4 = &temp4;
53500 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53501 }
53502 ecode5 = SWIG_AsVal_int(obj4, &val5);
53503 if (!SWIG_IsOK(ecode5)) {
53504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53505 }
53506 arg5 = static_cast< int >(val5);
53507 ecode6 = SWIG_AsVal_int(obj5, &val6);
53508 if (!SWIG_IsOK(ecode6)) {
53509 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53510 }
53511 arg6 = static_cast< int >(val6);
53512 if (obj6) {
53513 arg7 = obj6;
53514 }
53515 {
53516 PyThreadState* __tstate = wxPyBeginAllowThreads();
53517 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53518 wxPyEndAllowThreads(__tstate);
53519 if (PyErr_Occurred()) SWIG_fail;
53520 }
53521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53522 return resultobj;
53523 fail:
53524 return NULL;
53525 }
53526
53527
53528 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53529 PyObject *resultobj = 0;
53530 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53531 wxGBPosition result;
53532 void *argp1 = 0 ;
53533 int res1 = 0 ;
53534 PyObject *swig_obj[1] ;
53535
53536 if (!args) SWIG_fail;
53537 swig_obj[0] = args;
53538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53539 if (!SWIG_IsOK(res1)) {
53540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53541 }
53542 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53543 {
53544 PyThreadState* __tstate = wxPyBeginAllowThreads();
53545 result = ((wxGBSizerItem const *)arg1)->GetPos();
53546 wxPyEndAllowThreads(__tstate);
53547 if (PyErr_Occurred()) SWIG_fail;
53548 }
53549 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53550 return resultobj;
53551 fail:
53552 return NULL;
53553 }
53554
53555
53556 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53557 PyObject *resultobj = 0;
53558 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53559 wxGBSpan result;
53560 void *argp1 = 0 ;
53561 int res1 = 0 ;
53562 PyObject *swig_obj[1] ;
53563
53564 if (!args) SWIG_fail;
53565 swig_obj[0] = args;
53566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53567 if (!SWIG_IsOK(res1)) {
53568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53569 }
53570 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53571 {
53572 PyThreadState* __tstate = wxPyBeginAllowThreads();
53573 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53574 wxPyEndAllowThreads(__tstate);
53575 if (PyErr_Occurred()) SWIG_fail;
53576 }
53577 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53578 return resultobj;
53579 fail:
53580 return NULL;
53581 }
53582
53583
53584 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53585 PyObject *resultobj = 0;
53586 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53587 wxGBPosition *arg2 = 0 ;
53588 bool result;
53589 void *argp1 = 0 ;
53590 int res1 = 0 ;
53591 wxGBPosition temp2 ;
53592 PyObject * obj0 = 0 ;
53593 PyObject * obj1 = 0 ;
53594 char * kwnames[] = {
53595 (char *) "self",(char *) "pos", NULL
53596 };
53597
53598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53600 if (!SWIG_IsOK(res1)) {
53601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53602 }
53603 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53604 {
53605 arg2 = &temp2;
53606 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53607 }
53608 {
53609 PyThreadState* __tstate = wxPyBeginAllowThreads();
53610 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53611 wxPyEndAllowThreads(__tstate);
53612 if (PyErr_Occurred()) SWIG_fail;
53613 }
53614 {
53615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53616 }
53617 return resultobj;
53618 fail:
53619 return NULL;
53620 }
53621
53622
53623 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53624 PyObject *resultobj = 0;
53625 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53626 wxGBSpan *arg2 = 0 ;
53627 bool result;
53628 void *argp1 = 0 ;
53629 int res1 = 0 ;
53630 wxGBSpan temp2 ;
53631 PyObject * obj0 = 0 ;
53632 PyObject * obj1 = 0 ;
53633 char * kwnames[] = {
53634 (char *) "self",(char *) "span", NULL
53635 };
53636
53637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53639 if (!SWIG_IsOK(res1)) {
53640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53641 }
53642 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53643 {
53644 arg2 = &temp2;
53645 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53646 }
53647 {
53648 PyThreadState* __tstate = wxPyBeginAllowThreads();
53649 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53650 wxPyEndAllowThreads(__tstate);
53651 if (PyErr_Occurred()) SWIG_fail;
53652 }
53653 {
53654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53655 }
53656 return resultobj;
53657 fail:
53658 return NULL;
53659 }
53660
53661
53662 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53663 PyObject *resultobj = 0;
53664 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53665 wxGBSizerItem *arg2 = 0 ;
53666 bool result;
53667 void *argp1 = 0 ;
53668 int res1 = 0 ;
53669 void *argp2 = 0 ;
53670 int res2 = 0 ;
53671 PyObject * obj0 = 0 ;
53672 PyObject * obj1 = 0 ;
53673 char * kwnames[] = {
53674 (char *) "self",(char *) "other", NULL
53675 };
53676
53677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53679 if (!SWIG_IsOK(res1)) {
53680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53681 }
53682 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53683 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53684 if (!SWIG_IsOK(res2)) {
53685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53686 }
53687 if (!argp2) {
53688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53689 }
53690 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53691 {
53692 PyThreadState* __tstate = wxPyBeginAllowThreads();
53693 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53694 wxPyEndAllowThreads(__tstate);
53695 if (PyErr_Occurred()) SWIG_fail;
53696 }
53697 {
53698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53699 }
53700 return resultobj;
53701 fail:
53702 return NULL;
53703 }
53704
53705
53706 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53707 PyObject *resultobj = 0;
53708 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53709 wxGBPosition *arg2 = 0 ;
53710 wxGBSpan *arg3 = 0 ;
53711 bool result;
53712 void *argp1 = 0 ;
53713 int res1 = 0 ;
53714 wxGBPosition temp2 ;
53715 wxGBSpan temp3 ;
53716 PyObject * obj0 = 0 ;
53717 PyObject * obj1 = 0 ;
53718 PyObject * obj2 = 0 ;
53719 char * kwnames[] = {
53720 (char *) "self",(char *) "pos",(char *) "span", NULL
53721 };
53722
53723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53725 if (!SWIG_IsOK(res1)) {
53726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53727 }
53728 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53729 {
53730 arg2 = &temp2;
53731 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53732 }
53733 {
53734 arg3 = &temp3;
53735 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53736 }
53737 {
53738 PyThreadState* __tstate = wxPyBeginAllowThreads();
53739 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53740 wxPyEndAllowThreads(__tstate);
53741 if (PyErr_Occurred()) SWIG_fail;
53742 }
53743 {
53744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53745 }
53746 return resultobj;
53747 fail:
53748 return NULL;
53749 }
53750
53751
53752 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53753 PyObject *resultobj = 0;
53754 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53755 wxGBPosition result;
53756 void *argp1 = 0 ;
53757 int res1 = 0 ;
53758 PyObject *swig_obj[1] ;
53759
53760 if (!args) SWIG_fail;
53761 swig_obj[0] = args;
53762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53763 if (!SWIG_IsOK(res1)) {
53764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53765 }
53766 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53767 {
53768 PyThreadState* __tstate = wxPyBeginAllowThreads();
53769 result = wxGBSizerItem_GetEndPos(arg1);
53770 wxPyEndAllowThreads(__tstate);
53771 if (PyErr_Occurred()) SWIG_fail;
53772 }
53773 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53774 return resultobj;
53775 fail:
53776 return NULL;
53777 }
53778
53779
53780 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53781 PyObject *resultobj = 0;
53782 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53783 wxGridBagSizer *result = 0 ;
53784 void *argp1 = 0 ;
53785 int res1 = 0 ;
53786 PyObject *swig_obj[1] ;
53787
53788 if (!args) SWIG_fail;
53789 swig_obj[0] = args;
53790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53791 if (!SWIG_IsOK(res1)) {
53792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53793 }
53794 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53795 {
53796 PyThreadState* __tstate = wxPyBeginAllowThreads();
53797 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53798 wxPyEndAllowThreads(__tstate);
53799 if (PyErr_Occurred()) SWIG_fail;
53800 }
53801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53802 return resultobj;
53803 fail:
53804 return NULL;
53805 }
53806
53807
53808 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53809 PyObject *resultobj = 0;
53810 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53811 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53812 void *argp1 = 0 ;
53813 int res1 = 0 ;
53814 void *argp2 = 0 ;
53815 int res2 = 0 ;
53816 PyObject * obj0 = 0 ;
53817 PyObject * obj1 = 0 ;
53818 char * kwnames[] = {
53819 (char *) "self",(char *) "sizer", NULL
53820 };
53821
53822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53824 if (!SWIG_IsOK(res1)) {
53825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53826 }
53827 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53828 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53829 if (!SWIG_IsOK(res2)) {
53830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53831 }
53832 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53833 {
53834 PyThreadState* __tstate = wxPyBeginAllowThreads();
53835 (arg1)->SetGBSizer(arg2);
53836 wxPyEndAllowThreads(__tstate);
53837 if (PyErr_Occurred()) SWIG_fail;
53838 }
53839 resultobj = SWIG_Py_Void();
53840 return resultobj;
53841 fail:
53842 return NULL;
53843 }
53844
53845
53846 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53847 PyObject *obj;
53848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53849 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53850 return SWIG_Py_Void();
53851 }
53852
53853 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53854 return SWIG_Python_InitShadowInstance(args);
53855 }
53856
53857 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53858 PyObject *resultobj = 0;
53859 int arg1 = (int) 0 ;
53860 int arg2 = (int) 0 ;
53861 wxGridBagSizer *result = 0 ;
53862 int val1 ;
53863 int ecode1 = 0 ;
53864 int val2 ;
53865 int ecode2 = 0 ;
53866 PyObject * obj0 = 0 ;
53867 PyObject * obj1 = 0 ;
53868 char * kwnames[] = {
53869 (char *) "vgap",(char *) "hgap", NULL
53870 };
53871
53872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53873 if (obj0) {
53874 ecode1 = SWIG_AsVal_int(obj0, &val1);
53875 if (!SWIG_IsOK(ecode1)) {
53876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53877 }
53878 arg1 = static_cast< int >(val1);
53879 }
53880 if (obj1) {
53881 ecode2 = SWIG_AsVal_int(obj1, &val2);
53882 if (!SWIG_IsOK(ecode2)) {
53883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53884 }
53885 arg2 = static_cast< int >(val2);
53886 }
53887 {
53888 PyThreadState* __tstate = wxPyBeginAllowThreads();
53889 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53890 wxPyEndAllowThreads(__tstate);
53891 if (PyErr_Occurred()) SWIG_fail;
53892 }
53893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53894 return resultobj;
53895 fail:
53896 return NULL;
53897 }
53898
53899
53900 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53901 PyObject *resultobj = 0;
53902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53903 PyObject *arg2 = (PyObject *) 0 ;
53904 wxGBPosition *arg3 = 0 ;
53905 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53906 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53907 int arg5 = (int) 0 ;
53908 int arg6 = (int) 0 ;
53909 PyObject *arg7 = (PyObject *) NULL ;
53910 wxGBSizerItem *result = 0 ;
53911 void *argp1 = 0 ;
53912 int res1 = 0 ;
53913 wxGBPosition temp3 ;
53914 wxGBSpan temp4 ;
53915 int val5 ;
53916 int ecode5 = 0 ;
53917 int val6 ;
53918 int ecode6 = 0 ;
53919 PyObject * obj0 = 0 ;
53920 PyObject * obj1 = 0 ;
53921 PyObject * obj2 = 0 ;
53922 PyObject * obj3 = 0 ;
53923 PyObject * obj4 = 0 ;
53924 PyObject * obj5 = 0 ;
53925 PyObject * obj6 = 0 ;
53926 char * kwnames[] = {
53927 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53928 };
53929
53930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53932 if (!SWIG_IsOK(res1)) {
53933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53934 }
53935 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53936 arg2 = obj1;
53937 {
53938 arg3 = &temp3;
53939 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53940 }
53941 if (obj3) {
53942 {
53943 arg4 = &temp4;
53944 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53945 }
53946 }
53947 if (obj4) {
53948 ecode5 = SWIG_AsVal_int(obj4, &val5);
53949 if (!SWIG_IsOK(ecode5)) {
53950 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53951 }
53952 arg5 = static_cast< int >(val5);
53953 }
53954 if (obj5) {
53955 ecode6 = SWIG_AsVal_int(obj5, &val6);
53956 if (!SWIG_IsOK(ecode6)) {
53957 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53958 }
53959 arg6 = static_cast< int >(val6);
53960 }
53961 if (obj6) {
53962 arg7 = obj6;
53963 }
53964 {
53965 PyThreadState* __tstate = wxPyBeginAllowThreads();
53966 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53967 wxPyEndAllowThreads(__tstate);
53968 if (PyErr_Occurred()) SWIG_fail;
53969 }
53970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53971 return resultobj;
53972 fail:
53973 return NULL;
53974 }
53975
53976
53977 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53978 PyObject *resultobj = 0;
53979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53980 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53981 wxGBSizerItem *result = 0 ;
53982 void *argp1 = 0 ;
53983 int res1 = 0 ;
53984 int res2 = 0 ;
53985 PyObject * obj0 = 0 ;
53986 PyObject * obj1 = 0 ;
53987 char * kwnames[] = {
53988 (char *) "self",(char *) "item", NULL
53989 };
53990
53991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53993 if (!SWIG_IsOK(res1)) {
53994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53995 }
53996 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53997 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53998 if (!SWIG_IsOK(res2)) {
53999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54000 }
54001 {
54002 PyThreadState* __tstate = wxPyBeginAllowThreads();
54003 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54004 wxPyEndAllowThreads(__tstate);
54005 if (PyErr_Occurred()) SWIG_fail;
54006 }
54007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54008 return resultobj;
54009 fail:
54010 return NULL;
54011 }
54012
54013
54014 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54015 PyObject *resultobj = 0;
54016 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54017 int arg2 ;
54018 int arg3 ;
54019 wxSize result;
54020 void *argp1 = 0 ;
54021 int res1 = 0 ;
54022 int val2 ;
54023 int ecode2 = 0 ;
54024 int val3 ;
54025 int ecode3 = 0 ;
54026 PyObject * obj0 = 0 ;
54027 PyObject * obj1 = 0 ;
54028 PyObject * obj2 = 0 ;
54029 char * kwnames[] = {
54030 (char *) "self",(char *) "row",(char *) "col", NULL
54031 };
54032
54033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54035 if (!SWIG_IsOK(res1)) {
54036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54037 }
54038 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54039 ecode2 = SWIG_AsVal_int(obj1, &val2);
54040 if (!SWIG_IsOK(ecode2)) {
54041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54042 }
54043 arg2 = static_cast< int >(val2);
54044 ecode3 = SWIG_AsVal_int(obj2, &val3);
54045 if (!SWIG_IsOK(ecode3)) {
54046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54047 }
54048 arg3 = static_cast< int >(val3);
54049 {
54050 PyThreadState* __tstate = wxPyBeginAllowThreads();
54051 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54052 wxPyEndAllowThreads(__tstate);
54053 if (PyErr_Occurred()) SWIG_fail;
54054 }
54055 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54056 return resultobj;
54057 fail:
54058 return NULL;
54059 }
54060
54061
54062 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54063 PyObject *resultobj = 0;
54064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54065 wxSize result;
54066 void *argp1 = 0 ;
54067 int res1 = 0 ;
54068 PyObject *swig_obj[1] ;
54069
54070 if (!args) SWIG_fail;
54071 swig_obj[0] = args;
54072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54073 if (!SWIG_IsOK(res1)) {
54074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54075 }
54076 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54077 {
54078 PyThreadState* __tstate = wxPyBeginAllowThreads();
54079 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54080 wxPyEndAllowThreads(__tstate);
54081 if (PyErr_Occurred()) SWIG_fail;
54082 }
54083 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54084 return resultobj;
54085 fail:
54086 return NULL;
54087 }
54088
54089
54090 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54091 PyObject *resultobj = 0;
54092 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54093 wxSize *arg2 = 0 ;
54094 void *argp1 = 0 ;
54095 int res1 = 0 ;
54096 wxSize temp2 ;
54097 PyObject * obj0 = 0 ;
54098 PyObject * obj1 = 0 ;
54099 char * kwnames[] = {
54100 (char *) "self",(char *) "sz", NULL
54101 };
54102
54103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54105 if (!SWIG_IsOK(res1)) {
54106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54107 }
54108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54109 {
54110 arg2 = &temp2;
54111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54112 }
54113 {
54114 PyThreadState* __tstate = wxPyBeginAllowThreads();
54115 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54116 wxPyEndAllowThreads(__tstate);
54117 if (PyErr_Occurred()) SWIG_fail;
54118 }
54119 resultobj = SWIG_Py_Void();
54120 return resultobj;
54121 fail:
54122 return NULL;
54123 }
54124
54125
54126 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54127 PyObject *resultobj = 0;
54128 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54129 wxWindow *arg2 = (wxWindow *) 0 ;
54130 wxGBPosition result;
54131 void *argp1 = 0 ;
54132 int res1 = 0 ;
54133 void *argp2 = 0 ;
54134 int res2 = 0 ;
54135
54136 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54138 if (!SWIG_IsOK(res1)) {
54139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54140 }
54141 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54142 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54143 if (!SWIG_IsOK(res2)) {
54144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54145 }
54146 arg2 = reinterpret_cast< wxWindow * >(argp2);
54147 {
54148 PyThreadState* __tstate = wxPyBeginAllowThreads();
54149 result = (arg1)->GetItemPosition(arg2);
54150 wxPyEndAllowThreads(__tstate);
54151 if (PyErr_Occurred()) SWIG_fail;
54152 }
54153 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54154 return resultobj;
54155 fail:
54156 return NULL;
54157 }
54158
54159
54160 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54161 PyObject *resultobj = 0;
54162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54163 wxSizer *arg2 = (wxSizer *) 0 ;
54164 wxGBPosition result;
54165 void *argp1 = 0 ;
54166 int res1 = 0 ;
54167 void *argp2 = 0 ;
54168 int res2 = 0 ;
54169
54170 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54172 if (!SWIG_IsOK(res1)) {
54173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54174 }
54175 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54176 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54177 if (!SWIG_IsOK(res2)) {
54178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54179 }
54180 arg2 = reinterpret_cast< wxSizer * >(argp2);
54181 {
54182 PyThreadState* __tstate = wxPyBeginAllowThreads();
54183 result = (arg1)->GetItemPosition(arg2);
54184 wxPyEndAllowThreads(__tstate);
54185 if (PyErr_Occurred()) SWIG_fail;
54186 }
54187 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54188 return resultobj;
54189 fail:
54190 return NULL;
54191 }
54192
54193
54194 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54195 PyObject *resultobj = 0;
54196 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54197 size_t arg2 ;
54198 wxGBPosition result;
54199 void *argp1 = 0 ;
54200 int res1 = 0 ;
54201 size_t val2 ;
54202 int ecode2 = 0 ;
54203
54204 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54206 if (!SWIG_IsOK(res1)) {
54207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54208 }
54209 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54210 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54211 if (!SWIG_IsOK(ecode2)) {
54212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54213 }
54214 arg2 = static_cast< size_t >(val2);
54215 {
54216 PyThreadState* __tstate = wxPyBeginAllowThreads();
54217 result = (arg1)->GetItemPosition(arg2);
54218 wxPyEndAllowThreads(__tstate);
54219 if (PyErr_Occurred()) SWIG_fail;
54220 }
54221 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54222 return resultobj;
54223 fail:
54224 return NULL;
54225 }
54226
54227
54228 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54229 int argc;
54230 PyObject *argv[3];
54231
54232 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54233 --argc;
54234 if (argc == 2) {
54235 int _v = 0;
54236 {
54237 void *vptr = 0;
54238 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54239 _v = SWIG_CheckState(res);
54240 }
54241 if (!_v) goto check_1;
54242 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54243 }
54244 check_1:
54245
54246 if (argc == 2) {
54247 int _v = 0;
54248 {
54249 void *vptr = 0;
54250 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54251 _v = SWIG_CheckState(res);
54252 }
54253 if (!_v) goto check_2;
54254 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54255 }
54256 check_2:
54257
54258 if (argc == 2) {
54259 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54260 }
54261
54262 fail:
54263 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54264 return NULL;
54265 }
54266
54267
54268 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54269 PyObject *resultobj = 0;
54270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54271 wxWindow *arg2 = (wxWindow *) 0 ;
54272 wxGBPosition *arg3 = 0 ;
54273 bool result;
54274 void *argp1 = 0 ;
54275 int res1 = 0 ;
54276 void *argp2 = 0 ;
54277 int res2 = 0 ;
54278 wxGBPosition temp3 ;
54279
54280 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54282 if (!SWIG_IsOK(res1)) {
54283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54284 }
54285 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54286 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54287 if (!SWIG_IsOK(res2)) {
54288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54289 }
54290 arg2 = reinterpret_cast< wxWindow * >(argp2);
54291 {
54292 arg3 = &temp3;
54293 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54294 }
54295 {
54296 PyThreadState* __tstate = wxPyBeginAllowThreads();
54297 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54298 wxPyEndAllowThreads(__tstate);
54299 if (PyErr_Occurred()) SWIG_fail;
54300 }
54301 {
54302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54303 }
54304 return resultobj;
54305 fail:
54306 return NULL;
54307 }
54308
54309
54310 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54311 PyObject *resultobj = 0;
54312 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54313 wxSizer *arg2 = (wxSizer *) 0 ;
54314 wxGBPosition *arg3 = 0 ;
54315 bool result;
54316 void *argp1 = 0 ;
54317 int res1 = 0 ;
54318 void *argp2 = 0 ;
54319 int res2 = 0 ;
54320 wxGBPosition temp3 ;
54321
54322 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54324 if (!SWIG_IsOK(res1)) {
54325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54326 }
54327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54328 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54329 if (!SWIG_IsOK(res2)) {
54330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54331 }
54332 arg2 = reinterpret_cast< wxSizer * >(argp2);
54333 {
54334 arg3 = &temp3;
54335 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54336 }
54337 {
54338 PyThreadState* __tstate = wxPyBeginAllowThreads();
54339 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54340 wxPyEndAllowThreads(__tstate);
54341 if (PyErr_Occurred()) SWIG_fail;
54342 }
54343 {
54344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54345 }
54346 return resultobj;
54347 fail:
54348 return NULL;
54349 }
54350
54351
54352 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54353 PyObject *resultobj = 0;
54354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54355 size_t arg2 ;
54356 wxGBPosition *arg3 = 0 ;
54357 bool result;
54358 void *argp1 = 0 ;
54359 int res1 = 0 ;
54360 size_t val2 ;
54361 int ecode2 = 0 ;
54362 wxGBPosition temp3 ;
54363
54364 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54366 if (!SWIG_IsOK(res1)) {
54367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54368 }
54369 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54370 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54371 if (!SWIG_IsOK(ecode2)) {
54372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54373 }
54374 arg2 = static_cast< size_t >(val2);
54375 {
54376 arg3 = &temp3;
54377 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54378 }
54379 {
54380 PyThreadState* __tstate = wxPyBeginAllowThreads();
54381 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54382 wxPyEndAllowThreads(__tstate);
54383 if (PyErr_Occurred()) SWIG_fail;
54384 }
54385 {
54386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54387 }
54388 return resultobj;
54389 fail:
54390 return NULL;
54391 }
54392
54393
54394 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54395 int argc;
54396 PyObject *argv[4];
54397
54398 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54399 --argc;
54400 if (argc == 3) {
54401 int _v = 0;
54402 {
54403 void *vptr = 0;
54404 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54405 _v = SWIG_CheckState(res);
54406 }
54407 if (!_v) goto check_1;
54408 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54409 }
54410 check_1:
54411
54412 if (argc == 3) {
54413 int _v = 0;
54414 {
54415 void *vptr = 0;
54416 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54417 _v = SWIG_CheckState(res);
54418 }
54419 if (!_v) goto check_2;
54420 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54421 }
54422 check_2:
54423
54424 if (argc == 3) {
54425 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54426 }
54427
54428 fail:
54429 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54430 return NULL;
54431 }
54432
54433
54434 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54435 PyObject *resultobj = 0;
54436 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54437 wxWindow *arg2 = (wxWindow *) 0 ;
54438 wxGBSpan result;
54439 void *argp1 = 0 ;
54440 int res1 = 0 ;
54441 void *argp2 = 0 ;
54442 int res2 = 0 ;
54443
54444 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54446 if (!SWIG_IsOK(res1)) {
54447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54448 }
54449 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54450 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54451 if (!SWIG_IsOK(res2)) {
54452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54453 }
54454 arg2 = reinterpret_cast< wxWindow * >(argp2);
54455 {
54456 PyThreadState* __tstate = wxPyBeginAllowThreads();
54457 result = (arg1)->GetItemSpan(arg2);
54458 wxPyEndAllowThreads(__tstate);
54459 if (PyErr_Occurred()) SWIG_fail;
54460 }
54461 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54462 return resultobj;
54463 fail:
54464 return NULL;
54465 }
54466
54467
54468 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54469 PyObject *resultobj = 0;
54470 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54471 wxSizer *arg2 = (wxSizer *) 0 ;
54472 wxGBSpan result;
54473 void *argp1 = 0 ;
54474 int res1 = 0 ;
54475 void *argp2 = 0 ;
54476 int res2 = 0 ;
54477
54478 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54480 if (!SWIG_IsOK(res1)) {
54481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54482 }
54483 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54485 if (!SWIG_IsOK(res2)) {
54486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54487 }
54488 arg2 = reinterpret_cast< wxSizer * >(argp2);
54489 {
54490 PyThreadState* __tstate = wxPyBeginAllowThreads();
54491 result = (arg1)->GetItemSpan(arg2);
54492 wxPyEndAllowThreads(__tstate);
54493 if (PyErr_Occurred()) SWIG_fail;
54494 }
54495 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54496 return resultobj;
54497 fail:
54498 return NULL;
54499 }
54500
54501
54502 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54503 PyObject *resultobj = 0;
54504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54505 size_t arg2 ;
54506 wxGBSpan result;
54507 void *argp1 = 0 ;
54508 int res1 = 0 ;
54509 size_t val2 ;
54510 int ecode2 = 0 ;
54511
54512 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54514 if (!SWIG_IsOK(res1)) {
54515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54516 }
54517 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54518 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54519 if (!SWIG_IsOK(ecode2)) {
54520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54521 }
54522 arg2 = static_cast< size_t >(val2);
54523 {
54524 PyThreadState* __tstate = wxPyBeginAllowThreads();
54525 result = (arg1)->GetItemSpan(arg2);
54526 wxPyEndAllowThreads(__tstate);
54527 if (PyErr_Occurred()) SWIG_fail;
54528 }
54529 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54530 return resultobj;
54531 fail:
54532 return NULL;
54533 }
54534
54535
54536 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54537 int argc;
54538 PyObject *argv[3];
54539
54540 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54541 --argc;
54542 if (argc == 2) {
54543 int _v = 0;
54544 {
54545 void *vptr = 0;
54546 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54547 _v = SWIG_CheckState(res);
54548 }
54549 if (!_v) goto check_1;
54550 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54551 }
54552 check_1:
54553
54554 if (argc == 2) {
54555 int _v = 0;
54556 {
54557 void *vptr = 0;
54558 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54559 _v = SWIG_CheckState(res);
54560 }
54561 if (!_v) goto check_2;
54562 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54563 }
54564 check_2:
54565
54566 if (argc == 2) {
54567 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54568 }
54569
54570 fail:
54571 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54572 return NULL;
54573 }
54574
54575
54576 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54577 PyObject *resultobj = 0;
54578 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54579 wxWindow *arg2 = (wxWindow *) 0 ;
54580 wxGBSpan *arg3 = 0 ;
54581 bool result;
54582 void *argp1 = 0 ;
54583 int res1 = 0 ;
54584 void *argp2 = 0 ;
54585 int res2 = 0 ;
54586 wxGBSpan temp3 ;
54587
54588 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54590 if (!SWIG_IsOK(res1)) {
54591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54592 }
54593 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54594 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54595 if (!SWIG_IsOK(res2)) {
54596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54597 }
54598 arg2 = reinterpret_cast< wxWindow * >(argp2);
54599 {
54600 arg3 = &temp3;
54601 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54602 }
54603 {
54604 PyThreadState* __tstate = wxPyBeginAllowThreads();
54605 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54606 wxPyEndAllowThreads(__tstate);
54607 if (PyErr_Occurred()) SWIG_fail;
54608 }
54609 {
54610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54611 }
54612 return resultobj;
54613 fail:
54614 return NULL;
54615 }
54616
54617
54618 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54619 PyObject *resultobj = 0;
54620 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54621 wxSizer *arg2 = (wxSizer *) 0 ;
54622 wxGBSpan *arg3 = 0 ;
54623 bool result;
54624 void *argp1 = 0 ;
54625 int res1 = 0 ;
54626 void *argp2 = 0 ;
54627 int res2 = 0 ;
54628 wxGBSpan temp3 ;
54629
54630 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54632 if (!SWIG_IsOK(res1)) {
54633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54634 }
54635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54636 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54637 if (!SWIG_IsOK(res2)) {
54638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54639 }
54640 arg2 = reinterpret_cast< wxSizer * >(argp2);
54641 {
54642 arg3 = &temp3;
54643 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54644 }
54645 {
54646 PyThreadState* __tstate = wxPyBeginAllowThreads();
54647 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54648 wxPyEndAllowThreads(__tstate);
54649 if (PyErr_Occurred()) SWIG_fail;
54650 }
54651 {
54652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54653 }
54654 return resultobj;
54655 fail:
54656 return NULL;
54657 }
54658
54659
54660 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54661 PyObject *resultobj = 0;
54662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54663 size_t arg2 ;
54664 wxGBSpan *arg3 = 0 ;
54665 bool result;
54666 void *argp1 = 0 ;
54667 int res1 = 0 ;
54668 size_t val2 ;
54669 int ecode2 = 0 ;
54670 wxGBSpan temp3 ;
54671
54672 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54674 if (!SWIG_IsOK(res1)) {
54675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54676 }
54677 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54678 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54679 if (!SWIG_IsOK(ecode2)) {
54680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54681 }
54682 arg2 = static_cast< size_t >(val2);
54683 {
54684 arg3 = &temp3;
54685 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54686 }
54687 {
54688 PyThreadState* __tstate = wxPyBeginAllowThreads();
54689 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54690 wxPyEndAllowThreads(__tstate);
54691 if (PyErr_Occurred()) SWIG_fail;
54692 }
54693 {
54694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54695 }
54696 return resultobj;
54697 fail:
54698 return NULL;
54699 }
54700
54701
54702 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54703 int argc;
54704 PyObject *argv[4];
54705
54706 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54707 --argc;
54708 if (argc == 3) {
54709 int _v = 0;
54710 {
54711 void *vptr = 0;
54712 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54713 _v = SWIG_CheckState(res);
54714 }
54715 if (!_v) goto check_1;
54716 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54717 }
54718 check_1:
54719
54720 if (argc == 3) {
54721 int _v = 0;
54722 {
54723 void *vptr = 0;
54724 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54725 _v = SWIG_CheckState(res);
54726 }
54727 if (!_v) goto check_2;
54728 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54729 }
54730 check_2:
54731
54732 if (argc == 3) {
54733 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54734 }
54735
54736 fail:
54737 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54738 return NULL;
54739 }
54740
54741
54742 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54743 PyObject *resultobj = 0;
54744 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54745 wxWindow *arg2 = (wxWindow *) 0 ;
54746 wxGBSizerItem *result = 0 ;
54747 void *argp1 = 0 ;
54748 int res1 = 0 ;
54749 void *argp2 = 0 ;
54750 int res2 = 0 ;
54751
54752 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54754 if (!SWIG_IsOK(res1)) {
54755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54756 }
54757 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54758 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54759 if (!SWIG_IsOK(res2)) {
54760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54761 }
54762 arg2 = reinterpret_cast< wxWindow * >(argp2);
54763 {
54764 PyThreadState* __tstate = wxPyBeginAllowThreads();
54765 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54766 wxPyEndAllowThreads(__tstate);
54767 if (PyErr_Occurred()) SWIG_fail;
54768 }
54769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54770 return resultobj;
54771 fail:
54772 return NULL;
54773 }
54774
54775
54776 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54777 PyObject *resultobj = 0;
54778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54779 wxSizer *arg2 = (wxSizer *) 0 ;
54780 wxGBSizerItem *result = 0 ;
54781 void *argp1 = 0 ;
54782 int res1 = 0 ;
54783 void *argp2 = 0 ;
54784 int res2 = 0 ;
54785
54786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54788 if (!SWIG_IsOK(res1)) {
54789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54790 }
54791 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54792 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54793 if (!SWIG_IsOK(res2)) {
54794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54795 }
54796 arg2 = reinterpret_cast< wxSizer * >(argp2);
54797 {
54798 PyThreadState* __tstate = wxPyBeginAllowThreads();
54799 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54800 wxPyEndAllowThreads(__tstate);
54801 if (PyErr_Occurred()) SWIG_fail;
54802 }
54803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54804 return resultobj;
54805 fail:
54806 return NULL;
54807 }
54808
54809
54810 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54811 int argc;
54812 PyObject *argv[3];
54813
54814 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54815 --argc;
54816 if (argc == 2) {
54817 int _v = 0;
54818 {
54819 void *vptr = 0;
54820 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54821 _v = SWIG_CheckState(res);
54822 }
54823 if (!_v) goto check_1;
54824 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54825 }
54826 check_1:
54827
54828 if (argc == 2) {
54829 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54830 }
54831
54832 fail:
54833 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54834 return NULL;
54835 }
54836
54837
54838 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54839 PyObject *resultobj = 0;
54840 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54841 wxGBPosition *arg2 = 0 ;
54842 wxGBSizerItem *result = 0 ;
54843 void *argp1 = 0 ;
54844 int res1 = 0 ;
54845 wxGBPosition temp2 ;
54846 PyObject * obj0 = 0 ;
54847 PyObject * obj1 = 0 ;
54848 char * kwnames[] = {
54849 (char *) "self",(char *) "pos", NULL
54850 };
54851
54852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54854 if (!SWIG_IsOK(res1)) {
54855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54856 }
54857 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54858 {
54859 arg2 = &temp2;
54860 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54861 }
54862 {
54863 PyThreadState* __tstate = wxPyBeginAllowThreads();
54864 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54865 wxPyEndAllowThreads(__tstate);
54866 if (PyErr_Occurred()) SWIG_fail;
54867 }
54868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54869 return resultobj;
54870 fail:
54871 return NULL;
54872 }
54873
54874
54875 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54876 PyObject *resultobj = 0;
54877 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54878 wxPoint *arg2 = 0 ;
54879 wxGBSizerItem *result = 0 ;
54880 void *argp1 = 0 ;
54881 int res1 = 0 ;
54882 wxPoint temp2 ;
54883 PyObject * obj0 = 0 ;
54884 PyObject * obj1 = 0 ;
54885 char * kwnames[] = {
54886 (char *) "self",(char *) "pt", NULL
54887 };
54888
54889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54891 if (!SWIG_IsOK(res1)) {
54892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54893 }
54894 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54895 {
54896 arg2 = &temp2;
54897 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54898 }
54899 {
54900 PyThreadState* __tstate = wxPyBeginAllowThreads();
54901 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54902 wxPyEndAllowThreads(__tstate);
54903 if (PyErr_Occurred()) SWIG_fail;
54904 }
54905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54906 return resultobj;
54907 fail:
54908 return NULL;
54909 }
54910
54911
54912 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54913 PyObject *resultobj = 0;
54914 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54915 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54916 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54917 bool result;
54918 void *argp1 = 0 ;
54919 int res1 = 0 ;
54920 void *argp2 = 0 ;
54921 int res2 = 0 ;
54922 void *argp3 = 0 ;
54923 int res3 = 0 ;
54924 PyObject * obj0 = 0 ;
54925 PyObject * obj1 = 0 ;
54926 PyObject * obj2 = 0 ;
54927 char * kwnames[] = {
54928 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54929 };
54930
54931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54933 if (!SWIG_IsOK(res1)) {
54934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54935 }
54936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54938 if (!SWIG_IsOK(res2)) {
54939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54940 }
54941 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54942 if (obj2) {
54943 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54944 if (!SWIG_IsOK(res3)) {
54945 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54946 }
54947 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54948 }
54949 {
54950 PyThreadState* __tstate = wxPyBeginAllowThreads();
54951 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54952 wxPyEndAllowThreads(__tstate);
54953 if (PyErr_Occurred()) SWIG_fail;
54954 }
54955 {
54956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54957 }
54958 return resultobj;
54959 fail:
54960 return NULL;
54961 }
54962
54963
54964 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54965 PyObject *resultobj = 0;
54966 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54967 wxGBPosition *arg2 = 0 ;
54968 wxGBSpan *arg3 = 0 ;
54969 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54970 bool result;
54971 void *argp1 = 0 ;
54972 int res1 = 0 ;
54973 wxGBPosition temp2 ;
54974 wxGBSpan temp3 ;
54975 void *argp4 = 0 ;
54976 int res4 = 0 ;
54977 PyObject * obj0 = 0 ;
54978 PyObject * obj1 = 0 ;
54979 PyObject * obj2 = 0 ;
54980 PyObject * obj3 = 0 ;
54981 char * kwnames[] = {
54982 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54983 };
54984
54985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54987 if (!SWIG_IsOK(res1)) {
54988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54989 }
54990 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54991 {
54992 arg2 = &temp2;
54993 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54994 }
54995 {
54996 arg3 = &temp3;
54997 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54998 }
54999 if (obj3) {
55000 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55001 if (!SWIG_IsOK(res4)) {
55002 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55003 }
55004 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55005 }
55006 {
55007 PyThreadState* __tstate = wxPyBeginAllowThreads();
55008 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55009 wxPyEndAllowThreads(__tstate);
55010 if (PyErr_Occurred()) SWIG_fail;
55011 }
55012 {
55013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55014 }
55015 return resultobj;
55016 fail:
55017 return NULL;
55018 }
55019
55020
55021 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55022 PyObject *obj;
55023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55024 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55025 return SWIG_Py_Void();
55026 }
55027
55028 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55029 return SWIG_Python_InitShadowInstance(args);
55030 }
55031
55032 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55033 PyObject *resultobj = 0;
55034 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55035 wxRelationship arg2 ;
55036 wxWindow *arg3 = (wxWindow *) 0 ;
55037 wxEdge arg4 ;
55038 int arg5 = (int) 0 ;
55039 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55040 void *argp1 = 0 ;
55041 int res1 = 0 ;
55042 int val2 ;
55043 int ecode2 = 0 ;
55044 void *argp3 = 0 ;
55045 int res3 = 0 ;
55046 int val4 ;
55047 int ecode4 = 0 ;
55048 int val5 ;
55049 int ecode5 = 0 ;
55050 int val6 ;
55051 int ecode6 = 0 ;
55052 PyObject * obj0 = 0 ;
55053 PyObject * obj1 = 0 ;
55054 PyObject * obj2 = 0 ;
55055 PyObject * obj3 = 0 ;
55056 PyObject * obj4 = 0 ;
55057 PyObject * obj5 = 0 ;
55058 char * kwnames[] = {
55059 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55060 };
55061
55062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55064 if (!SWIG_IsOK(res1)) {
55065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55066 }
55067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55068 ecode2 = SWIG_AsVal_int(obj1, &val2);
55069 if (!SWIG_IsOK(ecode2)) {
55070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55071 }
55072 arg2 = static_cast< wxRelationship >(val2);
55073 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55074 if (!SWIG_IsOK(res3)) {
55075 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55076 }
55077 arg3 = reinterpret_cast< wxWindow * >(argp3);
55078 ecode4 = SWIG_AsVal_int(obj3, &val4);
55079 if (!SWIG_IsOK(ecode4)) {
55080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55081 }
55082 arg4 = static_cast< wxEdge >(val4);
55083 if (obj4) {
55084 ecode5 = SWIG_AsVal_int(obj4, &val5);
55085 if (!SWIG_IsOK(ecode5)) {
55086 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55087 }
55088 arg5 = static_cast< int >(val5);
55089 }
55090 if (obj5) {
55091 ecode6 = SWIG_AsVal_int(obj5, &val6);
55092 if (!SWIG_IsOK(ecode6)) {
55093 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55094 }
55095 arg6 = static_cast< int >(val6);
55096 }
55097 {
55098 PyThreadState* __tstate = wxPyBeginAllowThreads();
55099 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55100 wxPyEndAllowThreads(__tstate);
55101 if (PyErr_Occurred()) SWIG_fail;
55102 }
55103 resultobj = SWIG_Py_Void();
55104 return resultobj;
55105 fail:
55106 return NULL;
55107 }
55108
55109
55110 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55111 PyObject *resultobj = 0;
55112 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55113 wxWindow *arg2 = (wxWindow *) 0 ;
55114 int arg3 = (int) 0 ;
55115 void *argp1 = 0 ;
55116 int res1 = 0 ;
55117 void *argp2 = 0 ;
55118 int res2 = 0 ;
55119 int val3 ;
55120 int ecode3 = 0 ;
55121 PyObject * obj0 = 0 ;
55122 PyObject * obj1 = 0 ;
55123 PyObject * obj2 = 0 ;
55124 char * kwnames[] = {
55125 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55126 };
55127
55128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55130 if (!SWIG_IsOK(res1)) {
55131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55132 }
55133 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55135 if (!SWIG_IsOK(res2)) {
55136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55137 }
55138 arg2 = reinterpret_cast< wxWindow * >(argp2);
55139 if (obj2) {
55140 ecode3 = SWIG_AsVal_int(obj2, &val3);
55141 if (!SWIG_IsOK(ecode3)) {
55142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55143 }
55144 arg3 = static_cast< int >(val3);
55145 }
55146 {
55147 PyThreadState* __tstate = wxPyBeginAllowThreads();
55148 (arg1)->LeftOf(arg2,arg3);
55149 wxPyEndAllowThreads(__tstate);
55150 if (PyErr_Occurred()) SWIG_fail;
55151 }
55152 resultobj = SWIG_Py_Void();
55153 return resultobj;
55154 fail:
55155 return NULL;
55156 }
55157
55158
55159 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55160 PyObject *resultobj = 0;
55161 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55162 wxWindow *arg2 = (wxWindow *) 0 ;
55163 int arg3 = (int) 0 ;
55164 void *argp1 = 0 ;
55165 int res1 = 0 ;
55166 void *argp2 = 0 ;
55167 int res2 = 0 ;
55168 int val3 ;
55169 int ecode3 = 0 ;
55170 PyObject * obj0 = 0 ;
55171 PyObject * obj1 = 0 ;
55172 PyObject * obj2 = 0 ;
55173 char * kwnames[] = {
55174 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55175 };
55176
55177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55179 if (!SWIG_IsOK(res1)) {
55180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55181 }
55182 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55184 if (!SWIG_IsOK(res2)) {
55185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55186 }
55187 arg2 = reinterpret_cast< wxWindow * >(argp2);
55188 if (obj2) {
55189 ecode3 = SWIG_AsVal_int(obj2, &val3);
55190 if (!SWIG_IsOK(ecode3)) {
55191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55192 }
55193 arg3 = static_cast< int >(val3);
55194 }
55195 {
55196 PyThreadState* __tstate = wxPyBeginAllowThreads();
55197 (arg1)->RightOf(arg2,arg3);
55198 wxPyEndAllowThreads(__tstate);
55199 if (PyErr_Occurred()) SWIG_fail;
55200 }
55201 resultobj = SWIG_Py_Void();
55202 return resultobj;
55203 fail:
55204 return NULL;
55205 }
55206
55207
55208 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55209 PyObject *resultobj = 0;
55210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55211 wxWindow *arg2 = (wxWindow *) 0 ;
55212 int arg3 = (int) 0 ;
55213 void *argp1 = 0 ;
55214 int res1 = 0 ;
55215 void *argp2 = 0 ;
55216 int res2 = 0 ;
55217 int val3 ;
55218 int ecode3 = 0 ;
55219 PyObject * obj0 = 0 ;
55220 PyObject * obj1 = 0 ;
55221 PyObject * obj2 = 0 ;
55222 char * kwnames[] = {
55223 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55224 };
55225
55226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55228 if (!SWIG_IsOK(res1)) {
55229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55230 }
55231 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55233 if (!SWIG_IsOK(res2)) {
55234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55235 }
55236 arg2 = reinterpret_cast< wxWindow * >(argp2);
55237 if (obj2) {
55238 ecode3 = SWIG_AsVal_int(obj2, &val3);
55239 if (!SWIG_IsOK(ecode3)) {
55240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55241 }
55242 arg3 = static_cast< int >(val3);
55243 }
55244 {
55245 PyThreadState* __tstate = wxPyBeginAllowThreads();
55246 (arg1)->Above(arg2,arg3);
55247 wxPyEndAllowThreads(__tstate);
55248 if (PyErr_Occurred()) SWIG_fail;
55249 }
55250 resultobj = SWIG_Py_Void();
55251 return resultobj;
55252 fail:
55253 return NULL;
55254 }
55255
55256
55257 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55258 PyObject *resultobj = 0;
55259 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55260 wxWindow *arg2 = (wxWindow *) 0 ;
55261 int arg3 = (int) 0 ;
55262 void *argp1 = 0 ;
55263 int res1 = 0 ;
55264 void *argp2 = 0 ;
55265 int res2 = 0 ;
55266 int val3 ;
55267 int ecode3 = 0 ;
55268 PyObject * obj0 = 0 ;
55269 PyObject * obj1 = 0 ;
55270 PyObject * obj2 = 0 ;
55271 char * kwnames[] = {
55272 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55273 };
55274
55275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55277 if (!SWIG_IsOK(res1)) {
55278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55279 }
55280 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55282 if (!SWIG_IsOK(res2)) {
55283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55284 }
55285 arg2 = reinterpret_cast< wxWindow * >(argp2);
55286 if (obj2) {
55287 ecode3 = SWIG_AsVal_int(obj2, &val3);
55288 if (!SWIG_IsOK(ecode3)) {
55289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55290 }
55291 arg3 = static_cast< int >(val3);
55292 }
55293 {
55294 PyThreadState* __tstate = wxPyBeginAllowThreads();
55295 (arg1)->Below(arg2,arg3);
55296 wxPyEndAllowThreads(__tstate);
55297 if (PyErr_Occurred()) SWIG_fail;
55298 }
55299 resultobj = SWIG_Py_Void();
55300 return resultobj;
55301 fail:
55302 return NULL;
55303 }
55304
55305
55306 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55307 PyObject *resultobj = 0;
55308 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55309 wxWindow *arg2 = (wxWindow *) 0 ;
55310 wxEdge arg3 ;
55311 int arg4 = (int) 0 ;
55312 void *argp1 = 0 ;
55313 int res1 = 0 ;
55314 void *argp2 = 0 ;
55315 int res2 = 0 ;
55316 int val3 ;
55317 int ecode3 = 0 ;
55318 int val4 ;
55319 int ecode4 = 0 ;
55320 PyObject * obj0 = 0 ;
55321 PyObject * obj1 = 0 ;
55322 PyObject * obj2 = 0 ;
55323 PyObject * obj3 = 0 ;
55324 char * kwnames[] = {
55325 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55326 };
55327
55328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55330 if (!SWIG_IsOK(res1)) {
55331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55332 }
55333 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55335 if (!SWIG_IsOK(res2)) {
55336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55337 }
55338 arg2 = reinterpret_cast< wxWindow * >(argp2);
55339 ecode3 = SWIG_AsVal_int(obj2, &val3);
55340 if (!SWIG_IsOK(ecode3)) {
55341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55342 }
55343 arg3 = static_cast< wxEdge >(val3);
55344 if (obj3) {
55345 ecode4 = SWIG_AsVal_int(obj3, &val4);
55346 if (!SWIG_IsOK(ecode4)) {
55347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55348 }
55349 arg4 = static_cast< int >(val4);
55350 }
55351 {
55352 PyThreadState* __tstate = wxPyBeginAllowThreads();
55353 (arg1)->SameAs(arg2,arg3,arg4);
55354 wxPyEndAllowThreads(__tstate);
55355 if (PyErr_Occurred()) SWIG_fail;
55356 }
55357 resultobj = SWIG_Py_Void();
55358 return resultobj;
55359 fail:
55360 return NULL;
55361 }
55362
55363
55364 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55365 PyObject *resultobj = 0;
55366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55367 wxWindow *arg2 = (wxWindow *) 0 ;
55368 wxEdge arg3 ;
55369 int arg4 ;
55370 void *argp1 = 0 ;
55371 int res1 = 0 ;
55372 void *argp2 = 0 ;
55373 int res2 = 0 ;
55374 int val3 ;
55375 int ecode3 = 0 ;
55376 int val4 ;
55377 int ecode4 = 0 ;
55378 PyObject * obj0 = 0 ;
55379 PyObject * obj1 = 0 ;
55380 PyObject * obj2 = 0 ;
55381 PyObject * obj3 = 0 ;
55382 char * kwnames[] = {
55383 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55384 };
55385
55386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55388 if (!SWIG_IsOK(res1)) {
55389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55390 }
55391 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55393 if (!SWIG_IsOK(res2)) {
55394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55395 }
55396 arg2 = reinterpret_cast< wxWindow * >(argp2);
55397 ecode3 = SWIG_AsVal_int(obj2, &val3);
55398 if (!SWIG_IsOK(ecode3)) {
55399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55400 }
55401 arg3 = static_cast< wxEdge >(val3);
55402 ecode4 = SWIG_AsVal_int(obj3, &val4);
55403 if (!SWIG_IsOK(ecode4)) {
55404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55405 }
55406 arg4 = static_cast< int >(val4);
55407 {
55408 PyThreadState* __tstate = wxPyBeginAllowThreads();
55409 (arg1)->PercentOf(arg2,arg3,arg4);
55410 wxPyEndAllowThreads(__tstate);
55411 if (PyErr_Occurred()) SWIG_fail;
55412 }
55413 resultobj = SWIG_Py_Void();
55414 return resultobj;
55415 fail:
55416 return NULL;
55417 }
55418
55419
55420 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55421 PyObject *resultobj = 0;
55422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55423 int arg2 ;
55424 void *argp1 = 0 ;
55425 int res1 = 0 ;
55426 int val2 ;
55427 int ecode2 = 0 ;
55428 PyObject * obj0 = 0 ;
55429 PyObject * obj1 = 0 ;
55430 char * kwnames[] = {
55431 (char *) "self",(char *) "val", NULL
55432 };
55433
55434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55436 if (!SWIG_IsOK(res1)) {
55437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55438 }
55439 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55440 ecode2 = SWIG_AsVal_int(obj1, &val2);
55441 if (!SWIG_IsOK(ecode2)) {
55442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55443 }
55444 arg2 = static_cast< int >(val2);
55445 {
55446 PyThreadState* __tstate = wxPyBeginAllowThreads();
55447 (arg1)->Absolute(arg2);
55448 wxPyEndAllowThreads(__tstate);
55449 if (PyErr_Occurred()) SWIG_fail;
55450 }
55451 resultobj = SWIG_Py_Void();
55452 return resultobj;
55453 fail:
55454 return NULL;
55455 }
55456
55457
55458 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55459 PyObject *resultobj = 0;
55460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55461 void *argp1 = 0 ;
55462 int res1 = 0 ;
55463 PyObject *swig_obj[1] ;
55464
55465 if (!args) SWIG_fail;
55466 swig_obj[0] = args;
55467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55468 if (!SWIG_IsOK(res1)) {
55469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55470 }
55471 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55472 {
55473 PyThreadState* __tstate = wxPyBeginAllowThreads();
55474 (arg1)->Unconstrained();
55475 wxPyEndAllowThreads(__tstate);
55476 if (PyErr_Occurred()) SWIG_fail;
55477 }
55478 resultobj = SWIG_Py_Void();
55479 return resultobj;
55480 fail:
55481 return NULL;
55482 }
55483
55484
55485 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55486 PyObject *resultobj = 0;
55487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55488 void *argp1 = 0 ;
55489 int res1 = 0 ;
55490 PyObject *swig_obj[1] ;
55491
55492 if (!args) SWIG_fail;
55493 swig_obj[0] = args;
55494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55495 if (!SWIG_IsOK(res1)) {
55496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55497 }
55498 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55499 {
55500 PyThreadState* __tstate = wxPyBeginAllowThreads();
55501 (arg1)->AsIs();
55502 wxPyEndAllowThreads(__tstate);
55503 if (PyErr_Occurred()) SWIG_fail;
55504 }
55505 resultobj = SWIG_Py_Void();
55506 return resultobj;
55507 fail:
55508 return NULL;
55509 }
55510
55511
55512 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55513 PyObject *resultobj = 0;
55514 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55515 wxWindow *result = 0 ;
55516 void *argp1 = 0 ;
55517 int res1 = 0 ;
55518 PyObject *swig_obj[1] ;
55519
55520 if (!args) SWIG_fail;
55521 swig_obj[0] = args;
55522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55523 if (!SWIG_IsOK(res1)) {
55524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55525 }
55526 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55527 {
55528 PyThreadState* __tstate = wxPyBeginAllowThreads();
55529 result = (wxWindow *)(arg1)->GetOtherWindow();
55530 wxPyEndAllowThreads(__tstate);
55531 if (PyErr_Occurred()) SWIG_fail;
55532 }
55533 {
55534 resultobj = wxPyMake_wxObject(result, 0);
55535 }
55536 return resultobj;
55537 fail:
55538 return NULL;
55539 }
55540
55541
55542 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55543 PyObject *resultobj = 0;
55544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55545 wxEdge result;
55546 void *argp1 = 0 ;
55547 int res1 = 0 ;
55548 PyObject *swig_obj[1] ;
55549
55550 if (!args) SWIG_fail;
55551 swig_obj[0] = args;
55552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55553 if (!SWIG_IsOK(res1)) {
55554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55555 }
55556 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55557 {
55558 PyThreadState* __tstate = wxPyBeginAllowThreads();
55559 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55560 wxPyEndAllowThreads(__tstate);
55561 if (PyErr_Occurred()) SWIG_fail;
55562 }
55563 resultobj = SWIG_From_int(static_cast< int >(result));
55564 return resultobj;
55565 fail:
55566 return NULL;
55567 }
55568
55569
55570 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55571 PyObject *resultobj = 0;
55572 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55573 wxEdge arg2 ;
55574 void *argp1 = 0 ;
55575 int res1 = 0 ;
55576 int val2 ;
55577 int ecode2 = 0 ;
55578 PyObject * obj0 = 0 ;
55579 PyObject * obj1 = 0 ;
55580 char * kwnames[] = {
55581 (char *) "self",(char *) "which", NULL
55582 };
55583
55584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55586 if (!SWIG_IsOK(res1)) {
55587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55588 }
55589 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55590 ecode2 = SWIG_AsVal_int(obj1, &val2);
55591 if (!SWIG_IsOK(ecode2)) {
55592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55593 }
55594 arg2 = static_cast< wxEdge >(val2);
55595 {
55596 PyThreadState* __tstate = wxPyBeginAllowThreads();
55597 (arg1)->SetEdge(arg2);
55598 wxPyEndAllowThreads(__tstate);
55599 if (PyErr_Occurred()) SWIG_fail;
55600 }
55601 resultobj = SWIG_Py_Void();
55602 return resultobj;
55603 fail:
55604 return NULL;
55605 }
55606
55607
55608 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55609 PyObject *resultobj = 0;
55610 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55611 int arg2 ;
55612 void *argp1 = 0 ;
55613 int res1 = 0 ;
55614 int val2 ;
55615 int ecode2 = 0 ;
55616 PyObject * obj0 = 0 ;
55617 PyObject * obj1 = 0 ;
55618 char * kwnames[] = {
55619 (char *) "self",(char *) "v", NULL
55620 };
55621
55622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55624 if (!SWIG_IsOK(res1)) {
55625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55626 }
55627 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55628 ecode2 = SWIG_AsVal_int(obj1, &val2);
55629 if (!SWIG_IsOK(ecode2)) {
55630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55631 }
55632 arg2 = static_cast< int >(val2);
55633 {
55634 PyThreadState* __tstate = wxPyBeginAllowThreads();
55635 (arg1)->SetValue(arg2);
55636 wxPyEndAllowThreads(__tstate);
55637 if (PyErr_Occurred()) SWIG_fail;
55638 }
55639 resultobj = SWIG_Py_Void();
55640 return resultobj;
55641 fail:
55642 return NULL;
55643 }
55644
55645
55646 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55647 PyObject *resultobj = 0;
55648 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55649 int result;
55650 void *argp1 = 0 ;
55651 int res1 = 0 ;
55652 PyObject *swig_obj[1] ;
55653
55654 if (!args) SWIG_fail;
55655 swig_obj[0] = args;
55656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55657 if (!SWIG_IsOK(res1)) {
55658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55659 }
55660 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55661 {
55662 PyThreadState* __tstate = wxPyBeginAllowThreads();
55663 result = (int)(arg1)->GetMargin();
55664 wxPyEndAllowThreads(__tstate);
55665 if (PyErr_Occurred()) SWIG_fail;
55666 }
55667 resultobj = SWIG_From_int(static_cast< int >(result));
55668 return resultobj;
55669 fail:
55670 return NULL;
55671 }
55672
55673
55674 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55675 PyObject *resultobj = 0;
55676 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55677 int arg2 ;
55678 void *argp1 = 0 ;
55679 int res1 = 0 ;
55680 int val2 ;
55681 int ecode2 = 0 ;
55682 PyObject * obj0 = 0 ;
55683 PyObject * obj1 = 0 ;
55684 char * kwnames[] = {
55685 (char *) "self",(char *) "m", NULL
55686 };
55687
55688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55690 if (!SWIG_IsOK(res1)) {
55691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55692 }
55693 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55694 ecode2 = SWIG_AsVal_int(obj1, &val2);
55695 if (!SWIG_IsOK(ecode2)) {
55696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55697 }
55698 arg2 = static_cast< int >(val2);
55699 {
55700 PyThreadState* __tstate = wxPyBeginAllowThreads();
55701 (arg1)->SetMargin(arg2);
55702 wxPyEndAllowThreads(__tstate);
55703 if (PyErr_Occurred()) SWIG_fail;
55704 }
55705 resultobj = SWIG_Py_Void();
55706 return resultobj;
55707 fail:
55708 return NULL;
55709 }
55710
55711
55712 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55713 PyObject *resultobj = 0;
55714 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55715 int result;
55716 void *argp1 = 0 ;
55717 int res1 = 0 ;
55718 PyObject *swig_obj[1] ;
55719
55720 if (!args) SWIG_fail;
55721 swig_obj[0] = args;
55722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55723 if (!SWIG_IsOK(res1)) {
55724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55725 }
55726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55727 {
55728 PyThreadState* __tstate = wxPyBeginAllowThreads();
55729 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55730 wxPyEndAllowThreads(__tstate);
55731 if (PyErr_Occurred()) SWIG_fail;
55732 }
55733 resultobj = SWIG_From_int(static_cast< int >(result));
55734 return resultobj;
55735 fail:
55736 return NULL;
55737 }
55738
55739
55740 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55741 PyObject *resultobj = 0;
55742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55743 int result;
55744 void *argp1 = 0 ;
55745 int res1 = 0 ;
55746 PyObject *swig_obj[1] ;
55747
55748 if (!args) SWIG_fail;
55749 swig_obj[0] = args;
55750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55751 if (!SWIG_IsOK(res1)) {
55752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55753 }
55754 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55755 {
55756 PyThreadState* __tstate = wxPyBeginAllowThreads();
55757 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55758 wxPyEndAllowThreads(__tstate);
55759 if (PyErr_Occurred()) SWIG_fail;
55760 }
55761 resultobj = SWIG_From_int(static_cast< int >(result));
55762 return resultobj;
55763 fail:
55764 return NULL;
55765 }
55766
55767
55768 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55769 PyObject *resultobj = 0;
55770 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55771 int result;
55772 void *argp1 = 0 ;
55773 int res1 = 0 ;
55774 PyObject *swig_obj[1] ;
55775
55776 if (!args) SWIG_fail;
55777 swig_obj[0] = args;
55778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55779 if (!SWIG_IsOK(res1)) {
55780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55781 }
55782 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55783 {
55784 PyThreadState* __tstate = wxPyBeginAllowThreads();
55785 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55786 wxPyEndAllowThreads(__tstate);
55787 if (PyErr_Occurred()) SWIG_fail;
55788 }
55789 resultobj = SWIG_From_int(static_cast< int >(result));
55790 return resultobj;
55791 fail:
55792 return NULL;
55793 }
55794
55795
55796 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55797 PyObject *resultobj = 0;
55798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55799 bool result;
55800 void *argp1 = 0 ;
55801 int res1 = 0 ;
55802 PyObject *swig_obj[1] ;
55803
55804 if (!args) SWIG_fail;
55805 swig_obj[0] = args;
55806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55807 if (!SWIG_IsOK(res1)) {
55808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55809 }
55810 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55811 {
55812 PyThreadState* __tstate = wxPyBeginAllowThreads();
55813 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55814 wxPyEndAllowThreads(__tstate);
55815 if (PyErr_Occurred()) SWIG_fail;
55816 }
55817 {
55818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55819 }
55820 return resultobj;
55821 fail:
55822 return NULL;
55823 }
55824
55825
55826 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55827 PyObject *resultobj = 0;
55828 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55829 bool arg2 ;
55830 void *argp1 = 0 ;
55831 int res1 = 0 ;
55832 bool val2 ;
55833 int ecode2 = 0 ;
55834 PyObject * obj0 = 0 ;
55835 PyObject * obj1 = 0 ;
55836 char * kwnames[] = {
55837 (char *) "self",(char *) "d", NULL
55838 };
55839
55840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55842 if (!SWIG_IsOK(res1)) {
55843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55844 }
55845 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55847 if (!SWIG_IsOK(ecode2)) {
55848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55849 }
55850 arg2 = static_cast< bool >(val2);
55851 {
55852 PyThreadState* __tstate = wxPyBeginAllowThreads();
55853 (arg1)->SetDone(arg2);
55854 wxPyEndAllowThreads(__tstate);
55855 if (PyErr_Occurred()) SWIG_fail;
55856 }
55857 resultobj = SWIG_Py_Void();
55858 return resultobj;
55859 fail:
55860 return NULL;
55861 }
55862
55863
55864 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55865 PyObject *resultobj = 0;
55866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55867 wxRelationship result;
55868 void *argp1 = 0 ;
55869 int res1 = 0 ;
55870 PyObject *swig_obj[1] ;
55871
55872 if (!args) SWIG_fail;
55873 swig_obj[0] = args;
55874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55875 if (!SWIG_IsOK(res1)) {
55876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55877 }
55878 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55879 {
55880 PyThreadState* __tstate = wxPyBeginAllowThreads();
55881 result = (wxRelationship)(arg1)->GetRelationship();
55882 wxPyEndAllowThreads(__tstate);
55883 if (PyErr_Occurred()) SWIG_fail;
55884 }
55885 resultobj = SWIG_From_int(static_cast< int >(result));
55886 return resultobj;
55887 fail:
55888 return NULL;
55889 }
55890
55891
55892 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55893 PyObject *resultobj = 0;
55894 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55895 wxRelationship arg2 ;
55896 void *argp1 = 0 ;
55897 int res1 = 0 ;
55898 int val2 ;
55899 int ecode2 = 0 ;
55900 PyObject * obj0 = 0 ;
55901 PyObject * obj1 = 0 ;
55902 char * kwnames[] = {
55903 (char *) "self",(char *) "r", NULL
55904 };
55905
55906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55908 if (!SWIG_IsOK(res1)) {
55909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55910 }
55911 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55912 ecode2 = SWIG_AsVal_int(obj1, &val2);
55913 if (!SWIG_IsOK(ecode2)) {
55914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55915 }
55916 arg2 = static_cast< wxRelationship >(val2);
55917 {
55918 PyThreadState* __tstate = wxPyBeginAllowThreads();
55919 (arg1)->SetRelationship(arg2);
55920 wxPyEndAllowThreads(__tstate);
55921 if (PyErr_Occurred()) SWIG_fail;
55922 }
55923 resultobj = SWIG_Py_Void();
55924 return resultobj;
55925 fail:
55926 return NULL;
55927 }
55928
55929
55930 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55931 PyObject *resultobj = 0;
55932 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55933 wxWindow *arg2 = (wxWindow *) 0 ;
55934 bool result;
55935 void *argp1 = 0 ;
55936 int res1 = 0 ;
55937 void *argp2 = 0 ;
55938 int res2 = 0 ;
55939 PyObject * obj0 = 0 ;
55940 PyObject * obj1 = 0 ;
55941 char * kwnames[] = {
55942 (char *) "self",(char *) "otherW", NULL
55943 };
55944
55945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55947 if (!SWIG_IsOK(res1)) {
55948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55949 }
55950 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55952 if (!SWIG_IsOK(res2)) {
55953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55954 }
55955 arg2 = reinterpret_cast< wxWindow * >(argp2);
55956 {
55957 PyThreadState* __tstate = wxPyBeginAllowThreads();
55958 result = (bool)(arg1)->ResetIfWin(arg2);
55959 wxPyEndAllowThreads(__tstate);
55960 if (PyErr_Occurred()) SWIG_fail;
55961 }
55962 {
55963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55964 }
55965 return resultobj;
55966 fail:
55967 return NULL;
55968 }
55969
55970
55971 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55972 PyObject *resultobj = 0;
55973 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55974 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55975 wxWindow *arg3 = (wxWindow *) 0 ;
55976 bool result;
55977 void *argp1 = 0 ;
55978 int res1 = 0 ;
55979 void *argp2 = 0 ;
55980 int res2 = 0 ;
55981 void *argp3 = 0 ;
55982 int res3 = 0 ;
55983 PyObject * obj0 = 0 ;
55984 PyObject * obj1 = 0 ;
55985 PyObject * obj2 = 0 ;
55986 char * kwnames[] = {
55987 (char *) "self",(char *) "constraints",(char *) "win", NULL
55988 };
55989
55990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55992 if (!SWIG_IsOK(res1)) {
55993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55994 }
55995 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55997 if (!SWIG_IsOK(res2)) {
55998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55999 }
56000 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56002 if (!SWIG_IsOK(res3)) {
56003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56004 }
56005 arg3 = reinterpret_cast< wxWindow * >(argp3);
56006 {
56007 PyThreadState* __tstate = wxPyBeginAllowThreads();
56008 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56009 wxPyEndAllowThreads(__tstate);
56010 if (PyErr_Occurred()) SWIG_fail;
56011 }
56012 {
56013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56014 }
56015 return resultobj;
56016 fail:
56017 return NULL;
56018 }
56019
56020
56021 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56022 PyObject *resultobj = 0;
56023 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56024 wxEdge arg2 ;
56025 wxWindow *arg3 = (wxWindow *) 0 ;
56026 wxWindow *arg4 = (wxWindow *) 0 ;
56027 int result;
56028 void *argp1 = 0 ;
56029 int res1 = 0 ;
56030 int val2 ;
56031 int ecode2 = 0 ;
56032 void *argp3 = 0 ;
56033 int res3 = 0 ;
56034 void *argp4 = 0 ;
56035 int res4 = 0 ;
56036 PyObject * obj0 = 0 ;
56037 PyObject * obj1 = 0 ;
56038 PyObject * obj2 = 0 ;
56039 PyObject * obj3 = 0 ;
56040 char * kwnames[] = {
56041 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56042 };
56043
56044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56046 if (!SWIG_IsOK(res1)) {
56047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56048 }
56049 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56050 ecode2 = SWIG_AsVal_int(obj1, &val2);
56051 if (!SWIG_IsOK(ecode2)) {
56052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56053 }
56054 arg2 = static_cast< wxEdge >(val2);
56055 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56056 if (!SWIG_IsOK(res3)) {
56057 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56058 }
56059 arg3 = reinterpret_cast< wxWindow * >(argp3);
56060 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56061 if (!SWIG_IsOK(res4)) {
56062 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56063 }
56064 arg4 = reinterpret_cast< wxWindow * >(argp4);
56065 {
56066 PyThreadState* __tstate = wxPyBeginAllowThreads();
56067 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56068 wxPyEndAllowThreads(__tstate);
56069 if (PyErr_Occurred()) SWIG_fail;
56070 }
56071 resultobj = SWIG_From_int(static_cast< int >(result));
56072 return resultobj;
56073 fail:
56074 return NULL;
56075 }
56076
56077
56078 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56079 PyObject *obj;
56080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56081 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56082 return SWIG_Py_Void();
56083 }
56084
56085 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56086 PyObject *resultobj = 0;
56087 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56088 wxIndividualLayoutConstraint *result = 0 ;
56089 void *argp1 = 0 ;
56090 int res1 = 0 ;
56091 PyObject *swig_obj[1] ;
56092
56093 if (!args) SWIG_fail;
56094 swig_obj[0] = args;
56095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56096 if (!SWIG_IsOK(res1)) {
56097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56098 }
56099 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56100 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56102 return resultobj;
56103 fail:
56104 return NULL;
56105 }
56106
56107
56108 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56109 PyObject *resultobj = 0;
56110 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56111 wxIndividualLayoutConstraint *result = 0 ;
56112 void *argp1 = 0 ;
56113 int res1 = 0 ;
56114 PyObject *swig_obj[1] ;
56115
56116 if (!args) SWIG_fail;
56117 swig_obj[0] = args;
56118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56119 if (!SWIG_IsOK(res1)) {
56120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56121 }
56122 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56123 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56125 return resultobj;
56126 fail:
56127 return NULL;
56128 }
56129
56130
56131 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56132 PyObject *resultobj = 0;
56133 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56134 wxIndividualLayoutConstraint *result = 0 ;
56135 void *argp1 = 0 ;
56136 int res1 = 0 ;
56137 PyObject *swig_obj[1] ;
56138
56139 if (!args) SWIG_fail;
56140 swig_obj[0] = args;
56141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56142 if (!SWIG_IsOK(res1)) {
56143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56144 }
56145 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56146 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56148 return resultobj;
56149 fail:
56150 return NULL;
56151 }
56152
56153
56154 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56155 PyObject *resultobj = 0;
56156 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56157 wxIndividualLayoutConstraint *result = 0 ;
56158 void *argp1 = 0 ;
56159 int res1 = 0 ;
56160 PyObject *swig_obj[1] ;
56161
56162 if (!args) SWIG_fail;
56163 swig_obj[0] = args;
56164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56165 if (!SWIG_IsOK(res1)) {
56166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56167 }
56168 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56169 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56171 return resultobj;
56172 fail:
56173 return NULL;
56174 }
56175
56176
56177 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56178 PyObject *resultobj = 0;
56179 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56180 wxIndividualLayoutConstraint *result = 0 ;
56181 void *argp1 = 0 ;
56182 int res1 = 0 ;
56183 PyObject *swig_obj[1] ;
56184
56185 if (!args) SWIG_fail;
56186 swig_obj[0] = args;
56187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56188 if (!SWIG_IsOK(res1)) {
56189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56190 }
56191 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56192 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56194 return resultobj;
56195 fail:
56196 return NULL;
56197 }
56198
56199
56200 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56201 PyObject *resultobj = 0;
56202 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56203 wxIndividualLayoutConstraint *result = 0 ;
56204 void *argp1 = 0 ;
56205 int res1 = 0 ;
56206 PyObject *swig_obj[1] ;
56207
56208 if (!args) SWIG_fail;
56209 swig_obj[0] = args;
56210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56211 if (!SWIG_IsOK(res1)) {
56212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56213 }
56214 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56215 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56217 return resultobj;
56218 fail:
56219 return NULL;
56220 }
56221
56222
56223 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56224 PyObject *resultobj = 0;
56225 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56226 wxIndividualLayoutConstraint *result = 0 ;
56227 void *argp1 = 0 ;
56228 int res1 = 0 ;
56229 PyObject *swig_obj[1] ;
56230
56231 if (!args) SWIG_fail;
56232 swig_obj[0] = args;
56233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56234 if (!SWIG_IsOK(res1)) {
56235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56236 }
56237 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56238 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56240 return resultobj;
56241 fail:
56242 return NULL;
56243 }
56244
56245
56246 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56247 PyObject *resultobj = 0;
56248 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56249 wxIndividualLayoutConstraint *result = 0 ;
56250 void *argp1 = 0 ;
56251 int res1 = 0 ;
56252 PyObject *swig_obj[1] ;
56253
56254 if (!args) SWIG_fail;
56255 swig_obj[0] = args;
56256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56257 if (!SWIG_IsOK(res1)) {
56258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56259 }
56260 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56261 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56263 return resultobj;
56264 fail:
56265 return NULL;
56266 }
56267
56268
56269 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56270 PyObject *resultobj = 0;
56271 wxLayoutConstraints *result = 0 ;
56272
56273 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56274 {
56275 PyThreadState* __tstate = wxPyBeginAllowThreads();
56276 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56277 wxPyEndAllowThreads(__tstate);
56278 if (PyErr_Occurred()) SWIG_fail;
56279 }
56280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56281 return resultobj;
56282 fail:
56283 return NULL;
56284 }
56285
56286
56287 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56288 PyObject *resultobj = 0;
56289 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56290 void *argp1 = 0 ;
56291 int res1 = 0 ;
56292 PyObject *swig_obj[1] ;
56293
56294 if (!args) SWIG_fail;
56295 swig_obj[0] = args;
56296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56297 if (!SWIG_IsOK(res1)) {
56298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56299 }
56300 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56301 {
56302 PyThreadState* __tstate = wxPyBeginAllowThreads();
56303 delete arg1;
56304
56305 wxPyEndAllowThreads(__tstate);
56306 if (PyErr_Occurred()) SWIG_fail;
56307 }
56308 resultobj = SWIG_Py_Void();
56309 return resultobj;
56310 fail:
56311 return NULL;
56312 }
56313
56314
56315 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56316 PyObject *resultobj = 0;
56317 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56318 wxWindow *arg2 = (wxWindow *) 0 ;
56319 int *arg3 = (int *) 0 ;
56320 bool result;
56321 void *argp1 = 0 ;
56322 int res1 = 0 ;
56323 void *argp2 = 0 ;
56324 int res2 = 0 ;
56325 int temp3 ;
56326 int res3 = SWIG_TMPOBJ ;
56327 PyObject * obj0 = 0 ;
56328 PyObject * obj1 = 0 ;
56329 char * kwnames[] = {
56330 (char *) "self",(char *) "win", NULL
56331 };
56332
56333 arg3 = &temp3;
56334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56336 if (!SWIG_IsOK(res1)) {
56337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56338 }
56339 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56341 if (!SWIG_IsOK(res2)) {
56342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56343 }
56344 arg2 = reinterpret_cast< wxWindow * >(argp2);
56345 {
56346 PyThreadState* __tstate = wxPyBeginAllowThreads();
56347 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56348 wxPyEndAllowThreads(__tstate);
56349 if (PyErr_Occurred()) SWIG_fail;
56350 }
56351 {
56352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56353 }
56354 if (SWIG_IsTmpObj(res3)) {
56355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56356 } else {
56357 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56359 }
56360 return resultobj;
56361 fail:
56362 return NULL;
56363 }
56364
56365
56366 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56367 PyObject *resultobj = 0;
56368 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56369 bool result;
56370 void *argp1 = 0 ;
56371 int res1 = 0 ;
56372 PyObject *swig_obj[1] ;
56373
56374 if (!args) SWIG_fail;
56375 swig_obj[0] = args;
56376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56377 if (!SWIG_IsOK(res1)) {
56378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56379 }
56380 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56381 {
56382 PyThreadState* __tstate = wxPyBeginAllowThreads();
56383 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56384 wxPyEndAllowThreads(__tstate);
56385 if (PyErr_Occurred()) SWIG_fail;
56386 }
56387 {
56388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56389 }
56390 return resultobj;
56391 fail:
56392 return NULL;
56393 }
56394
56395
56396 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56397 PyObject *obj;
56398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56399 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56400 return SWIG_Py_Void();
56401 }
56402
56403 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56404 return SWIG_Python_InitShadowInstance(args);
56405 }
56406
56407 static PyMethodDef SwigMethods[] = {
56408 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56409 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56410 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56411 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56412 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56413 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56414 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56415 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56416 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56417 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56419 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56420 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56425 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56432 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56433 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56434 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56436 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56437 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56438 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56439 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56440 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56441 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56442 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56444 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56450 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56451 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56452 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56453 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56454 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56455 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56456 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56458 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56466 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56467 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56468 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56473 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56474 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56476 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56478 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56480 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56482 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56484 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56486 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56487 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56489 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56491 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56493 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56495 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56496 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56497 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56498 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56518 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56519 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56520 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56521 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56522 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56523 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56524 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56525 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56527 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56528 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56529 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56534 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56535 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56536 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56537 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56538 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56545 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56552 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56553 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56554 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56555 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56557 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56558 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56559 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56561 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56562 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56563 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56564 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56567 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56570 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56573 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56576 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56578 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56579 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56582 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56585 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56588 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56594 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56596 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56605 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56608 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56609 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56610 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56611 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56612 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56613 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56614 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56615 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56617 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56618 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56619 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56621 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56622 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56623 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56624 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56629 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56630 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56631 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56632 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56633 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56634 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56637 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56638 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56639 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56641 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56642 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56644 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56645 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56646 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56647 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56648 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56649 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56650 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56651 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56652 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56653 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56654 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56655 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56660 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56666 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56667 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56668 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56669 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56671 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56674 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56677 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56680 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56681 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56682 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56685 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56686 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56687 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56691 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56692 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56693 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56697 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56702 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56703 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56704 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56705 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56706 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56707 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56708 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56715 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56716 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56718 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56719 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56720 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56726 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56727 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56729 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56730 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56731 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56732 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56733 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56734 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56735 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56736 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56738 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56739 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56740 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56741 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56742 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56743 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56744 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56745 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56747 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56756 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56773 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56774 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56789 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56790 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56791 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56792 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56795 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56797 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56799 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56801 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56803 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56806 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56807 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56808 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56809 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56811 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56828 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56829 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56835 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56836 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56838 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56839 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56840 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56841 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56842 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56843 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56844 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56845 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56846 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56847 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56848 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56849 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56850 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56851 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56852 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56853 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56854 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56855 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56856 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56857 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56858 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56859 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56860 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56861 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56862 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56863 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56864 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56865 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56866 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56867 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56868 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56869 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56870 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56872 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56873 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56874 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56875 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56878 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56879 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56882 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56883 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56884 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56885 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56889 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56890 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56891 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56892 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56893 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56894 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56895 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56897 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56899 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56900 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56901 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56903 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56904 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56905 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56906 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56907 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56908 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56910 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56911 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56912 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56914 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56915 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56916 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56918 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56920 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56921 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56922 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56924 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56926 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56927 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56929 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56930 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56931 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56933 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56934 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56935 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56936 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56937 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56939 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56940 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56943 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56944 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56946 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56947 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56950 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56951 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56952 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56953 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56959 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56960 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56961 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56962 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56963 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56964 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56965 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56966 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56967 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56968 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56969 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56970 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56971 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56972 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56973 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56974 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56975 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56976 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56977 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56978 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56979 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56980 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56981 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56982 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56984 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56985 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56986 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56987 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56988 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56989 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56990 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56991 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56992 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56993 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56994 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56995 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56996 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56997 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56998 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56999 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57000 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57001 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57002 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57003 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57004 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57005 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57006 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57007 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57008 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57009 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57010 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57011 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57012 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57013 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57014 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57015 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57016 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57017 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57018 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57019 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57020 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57021 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57022 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57023 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57025 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57026 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57027 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57028 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57029 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57030 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57031 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57032 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57033 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57034 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57035 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57036 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57037 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57038 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57039 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57040 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57041 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57042 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57043 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57044 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57045 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57046 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57047 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57048 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57049 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57050 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57051 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57052 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57053 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57054 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57055 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57056 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57057 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57058 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57059 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57060 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57061 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57062 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57063 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57064 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57065 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57066 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57067 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57068 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57069 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57070 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57071 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57072 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57073 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57075 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57076 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57079 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57080 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57082 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57083 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57085 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57086 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57087 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57088 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57089 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57090 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57091 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57092 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57094 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57095 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57097 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57101 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57102 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57103 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57104 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57105 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57106 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57108 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57109 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57110 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57115 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57117 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57119 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57120 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57121 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57124 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57125 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57126 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57128 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57129 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57130 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57132 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57133 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57134 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57135 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57136 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57137 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57139 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57140 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57141 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57142 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57143 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57144 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57145 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57146 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57147 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57152 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57154 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57156 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57157 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57158 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57159 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57160 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57161 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57163 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57164 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57165 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57167 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57168 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57169 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57170 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57171 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57172 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57174 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57175 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57176 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57179 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57180 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57181 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57182 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57183 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57184 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57185 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57187 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57190 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57192 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57193 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57195 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57196 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57197 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57199 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57200 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57201 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57203 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57205 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57206 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57207 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57209 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57211 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57212 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57213 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57214 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57216 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57217 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57218 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57219 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57221 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57225 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57226 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57227 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57228 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57229 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57231 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57232 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57233 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57234 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57235 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57236 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57237 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57238 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57240 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57242 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57243 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57244 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57245 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57247 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57248 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57249 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57250 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57251 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57252 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57253 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57254 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57255 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57257 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57259 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57261 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57263 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57264 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57265 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57267 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57268 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57269 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57270 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57271 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57272 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57278 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57279 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57280 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57281 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57282 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57283 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57284 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57285 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57287 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57289 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57290 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57292 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57293 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57294 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57295 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57297 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57298 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57299 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57300 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57302 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57303 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57305 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57306 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57307 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57309 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57312 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57313 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57314 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57315 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57316 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57318 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57319 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57321 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57322 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57323 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57324 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57326 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57327 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57328 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57329 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57330 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57331 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57332 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57333 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57334 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57335 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57337 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57340 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57341 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57342 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57344 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57346 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57348 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57350 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57351 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57354 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57357 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57364 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57365 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57369 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57370 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57371 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57372 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57373 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57374 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57375 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57376 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57377 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57378 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57379 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57380 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57381 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57382 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57383 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
57385 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57388 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57389 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57394 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57395 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57398 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57399 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57400 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57401 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57404 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57405 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57406 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57408 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57410 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57411 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57412 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57413 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57415 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57417 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57419 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57422 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57423 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57424 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57425 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57426 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57427 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57431 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57432 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57433 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57434 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57436 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57441 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57447 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57448 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57449 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57450 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57451 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57453 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57463 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57464 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57465 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57466 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57469 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57470 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57471 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57472 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57473 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57475 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57476 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57477 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57481 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57487 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57488 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57489 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57490 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57492 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57493 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57495 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57498 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57500 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57501 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57502 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57511 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57515 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57516 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57518 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57528 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57529 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57530 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57531 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57535 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57538 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57540 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57543 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57545 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57546 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57549 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57551 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57552 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57553 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57554 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57556 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57557 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57562 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57563 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57564 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57566 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57567 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57568 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57570 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57572 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57573 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57574 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57576 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57577 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57580 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57588 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57595 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57603 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57606 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57607 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57620 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57622 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57624 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57625 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57627 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57629 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57630 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57632 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57633 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57634 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57638 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57657 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57658 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57660 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57661 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57663 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57664 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57665 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57667 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57668 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57671 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57672 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57674 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57675 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57677 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57680 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57681 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57683 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57685 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57687 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57688 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57690 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57691 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57694 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57696 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57698 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57700 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57703 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57705 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57706 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57707 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57709 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57710 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57711 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57713 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57715 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57716 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57719 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57720 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57724 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57728 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57729 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57731 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57735 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57737 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57739 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57740 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57741 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57742 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57746 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57747 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57748 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57749 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57751 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57752 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57757 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57758 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57759 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57760 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57761 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57763 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57765 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57767 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57768 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57770 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57772 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57775 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57776 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57777 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57779 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57780 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57781 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57794 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57800 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57801 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57802 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57803 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57804 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57805 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57811 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57812 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57816 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57817 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57819 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57820 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57822 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57824 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57825 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57827 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57828 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57829 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57835 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57836 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57837 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57838 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57839 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57840 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57847 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57849 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57850 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57851 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57852 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57853 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57854 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57856 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57860 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57861 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57862 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57863 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57864 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57865 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57866 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57868 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57869 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57870 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57876 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57877 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57878 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57880 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57881 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57882 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57888 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57889 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57890 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57891 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57892 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57896 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57897 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57902 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57903 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57905 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57906 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57911 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57913 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57914 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57915 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57916 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57917 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57922 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57923 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57932 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57933 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57934 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57935 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57938 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57940 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57941 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57942 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57943 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57945 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57950 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57951 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57952 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57953 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57954 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57955 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57956 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57957 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57958 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57959 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57960 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57962 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57963 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57964 { NULL, NULL, 0, NULL }
57965 };
57966
57967
57968 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57969
57970 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57971 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57972 }
57973 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57974 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57975 }
57976 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57977 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57978 }
57979 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57980 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57981 }
57982 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57983 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57984 }
57985 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57986 return (void *)((wxSizer *) ((wxGridSizer *) x));
57987 }
57988 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57989 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57990 }
57991 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57992 return (void *)((wxSizer *) ((wxPySizer *) x));
57993 }
57994 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57995 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57996 }
57997 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57998 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57999 }
58000 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58001 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58002 }
58003 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58004 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58005 }
58006 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58007 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58008 }
58009 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58010 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58011 }
58012 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58013 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58014 }
58015 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58016 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58017 }
58018 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58019 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58020 }
58021 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58022 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58023 }
58024 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58025 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58026 }
58027 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58029 }
58030 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxPyEvent *) x));
58032 }
58033 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58035 }
58036 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58038 }
58039 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58041 }
58042 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58044 }
58045 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58047 }
58048 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58050 }
58051 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58053 }
58054 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58056 }
58057 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58059 }
58060 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58062 }
58063 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58065 }
58066 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58068 }
58069 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58071 }
58072 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58074 }
58075 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58077 }
58078 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58080 }
58081 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58083 }
58084 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58086 }
58087 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58089 }
58090 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58092 }
58093 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) ((wxShowEvent *) x));
58095 }
58096 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58098 }
58099 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58101 }
58102 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58104 }
58105 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58107 }
58108 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58110 }
58111 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58113 }
58114 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58115 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58116 }
58117 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58118 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58119 }
58120 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58121 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58122 }
58123 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58124 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58125 }
58126 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58127 return (void *)((wxControl *) ((wxControlWithItems *) x));
58128 }
58129 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58130 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58131 }
58132 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58133 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58134 }
58135 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58136 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58137 }
58138 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58139 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58140 }
58141 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58142 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58143 }
58144 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58145 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58146 }
58147 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58148 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58149 }
58150 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58151 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58152 }
58153 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58154 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58155 }
58156 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58157 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58158 }
58159 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58160 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58161 }
58162 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58163 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58164 }
58165 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58166 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58167 }
58168 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58169 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58170 }
58171 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58172 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58173 }
58174 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58175 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58176 }
58177 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58178 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58179 }
58180 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58181 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58182 }
58183 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58184 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58185 }
58186 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58187 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58188 }
58189 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58190 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58191 }
58192 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58193 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58194 }
58195 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58196 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58197 }
58198 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58199 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58200 }
58201 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58202 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58203 }
58204 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58205 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58206 }
58207 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58208 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58209 }
58210 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58211 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58212 }
58213 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58214 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58215 }
58216 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58217 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58218 }
58219 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58220 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58221 }
58222 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58223 return (void *)((wxObject *) ((wxSizerItem *) x));
58224 }
58225 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58226 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58227 }
58228 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58229 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58230 }
58231 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58232 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58233 }
58234 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58235 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58236 }
58237 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58238 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58239 }
58240 static void *_p_wxSizerTo_p_wxObject(void *x) {
58241 return (void *)((wxObject *) ((wxSizer *) x));
58242 }
58243 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58244 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58245 }
58246 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58248 }
58249 static void *_p_wxEventTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) ((wxEvent *) x));
58251 }
58252 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58254 }
58255 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58257 }
58258 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58260 }
58261 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58263 }
58264 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58266 }
58267 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58269 }
58270 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58272 }
58273 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58275 }
58276 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58278 }
58279 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58281 }
58282 static void *_p_wxControlTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58284 }
58285 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58287 }
58288 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxFSFile *) x));
58290 }
58291 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58293 }
58294 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58296 }
58297 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58299 }
58300 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58302 }
58303 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) ((wxMenuItem *) x));
58305 }
58306 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58308 }
58309 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58311 }
58312 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58314 }
58315 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58317 }
58318 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58320 }
58321 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58323 }
58324 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58326 }
58327 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58329 }
58330 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58332 }
58333 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58335 }
58336 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58338 }
58339 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58341 }
58342 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58344 }
58345 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58347 }
58348 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58350 }
58351 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58353 }
58354 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58356 }
58357 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58359 }
58360 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58362 }
58363 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) ((wxImageHandler *) x));
58365 }
58366 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58368 }
58369 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58371 }
58372 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) ((wxEvtHandler *) x));
58374 }
58375 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58377 }
58378 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58380 }
58381 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58383 }
58384 static void *_p_wxImageTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) ((wxImage *) x));
58386 }
58387 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58389 }
58390 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58392 }
58393 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58395 }
58396 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58398 }
58399 static void *_p_wxWindowTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58401 }
58402 static void *_p_wxMenuTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58404 }
58405 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58407 }
58408 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) ((wxFileSystem *) x));
58410 }
58411 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58413 }
58414 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58416 }
58417 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58419 }
58420 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58422 }
58423 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58425 }
58426 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58428 }
58429 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58431 }
58432 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58434 }
58435 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58437 }
58438 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58440 }
58441 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58443 }
58444 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58446 }
58447 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58449 }
58450 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58452 }
58453 static void *_p_wxControlTo_p_wxWindow(void *x) {
58454 return (void *)((wxWindow *) ((wxControl *) x));
58455 }
58456 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58457 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58458 }
58459 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58460 return (void *)((wxWindow *) ((wxMenuBar *) x));
58461 }
58462 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58463 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58464 }
58465 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58466 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58467 }
58468 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58469 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58470 }
58471 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58472 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58473 }
58474 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58475 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58476 }
58477 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58478 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58479 }
58480 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58481 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58482 }
58483 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58484 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58485 }
58486 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58487 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58488 }
58489 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58490 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58491 }
58492 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58493 return (void *)((wxValidator *) ((wxPyValidator *) x));
58494 }
58495 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58497 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};
58498 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58629
58630 static swig_type_info *swig_type_initial[] = {
58631 &_swigt__p_buffer,
58632 &_swigt__p_char,
58633 &_swigt__p_form_ops_t,
58634 &_swigt__p_int,
58635 &_swigt__p_long,
58636 &_swigt__p_unsigned_char,
58637 &_swigt__p_unsigned_int,
58638 &_swigt__p_unsigned_long,
58639 &_swigt__p_wxANIHandler,
58640 &_swigt__p_wxAcceleratorEntry,
58641 &_swigt__p_wxAcceleratorTable,
58642 &_swigt__p_wxActivateEvent,
58643 &_swigt__p_wxAppTraits,
58644 &_swigt__p_wxArrayString,
58645 &_swigt__p_wxBMPHandler,
58646 &_swigt__p_wxBitmap,
58647 &_swigt__p_wxBoxSizer,
58648 &_swigt__p_wxButton,
58649 &_swigt__p_wxCURHandler,
58650 &_swigt__p_wxCaret,
58651 &_swigt__p_wxChildFocusEvent,
58652 &_swigt__p_wxClipboardTextEvent,
58653 &_swigt__p_wxCloseEvent,
58654 &_swigt__p_wxColour,
58655 &_swigt__p_wxCommandEvent,
58656 &_swigt__p_wxContextMenuEvent,
58657 &_swigt__p_wxControl,
58658 &_swigt__p_wxControlWithItems,
58659 &_swigt__p_wxCursor,
58660 &_swigt__p_wxDC,
58661 &_swigt__p_wxDateEvent,
58662 &_swigt__p_wxDateTime,
58663 &_swigt__p_wxDisplayChangedEvent,
58664 &_swigt__p_wxDouble,
58665 &_swigt__p_wxDropFilesEvent,
58666 &_swigt__p_wxDuplexMode,
58667 &_swigt__p_wxEraseEvent,
58668 &_swigt__p_wxEvent,
58669 &_swigt__p_wxEventLoop,
58670 &_swigt__p_wxEventLoopActivator,
58671 &_swigt__p_wxEvtHandler,
58672 &_swigt__p_wxFSFile,
58673 &_swigt__p_wxFileSystem,
58674 &_swigt__p_wxFileSystemHandler,
58675 &_swigt__p_wxFlexGridSizer,
58676 &_swigt__p_wxFocusEvent,
58677 &_swigt__p_wxFont,
58678 &_swigt__p_wxFrame,
58679 &_swigt__p_wxGBPosition,
58680 &_swigt__p_wxGBSizerItem,
58681 &_swigt__p_wxGBSpan,
58682 &_swigt__p_wxGIFHandler,
58683 &_swigt__p_wxGridBagSizer,
58684 &_swigt__p_wxGridSizer,
58685 &_swigt__p_wxHelpEvent__Origin,
58686 &_swigt__p_wxICOHandler,
58687 &_swigt__p_wxIconizeEvent,
58688 &_swigt__p_wxIdleEvent,
58689 &_swigt__p_wxImage,
58690 &_swigt__p_wxImageHandler,
58691 &_swigt__p_wxImageHistogram,
58692 &_swigt__p_wxImage_HSVValue,
58693 &_swigt__p_wxImage_RGBValue,
58694 &_swigt__p_wxIndividualLayoutConstraint,
58695 &_swigt__p_wxInitDialogEvent,
58696 &_swigt__p_wxInputStream,
58697 &_swigt__p_wxInternetFSHandler,
58698 &_swigt__p_wxItemContainer,
58699 &_swigt__p_wxJPEGHandler,
58700 &_swigt__p_wxKeyEvent,
58701 &_swigt__p_wxLayoutConstraints,
58702 &_swigt__p_wxMaximizeEvent,
58703 &_swigt__p_wxMemoryFSHandler,
58704 &_swigt__p_wxMenu,
58705 &_swigt__p_wxMenuBar,
58706 &_swigt__p_wxMenuBarBase,
58707 &_swigt__p_wxMenuEvent,
58708 &_swigt__p_wxMenuItem,
58709 &_swigt__p_wxMouseCaptureChangedEvent,
58710 &_swigt__p_wxMouseCaptureLostEvent,
58711 &_swigt__p_wxMouseEvent,
58712 &_swigt__p_wxMoveEvent,
58713 &_swigt__p_wxNavigationKeyEvent,
58714 &_swigt__p_wxNcPaintEvent,
58715 &_swigt__p_wxNotifyEvent,
58716 &_swigt__p_wxObject,
58717 &_swigt__p_wxOutputStream,
58718 &_swigt__p_wxPCXHandler,
58719 &_swigt__p_wxPNGHandler,
58720 &_swigt__p_wxPNMHandler,
58721 &_swigt__p_wxPaintEvent,
58722 &_swigt__p_wxPaletteChangedEvent,
58723 &_swigt__p_wxPaperSize,
58724 &_swigt__p_wxPoint,
58725 &_swigt__p_wxPoint2D,
58726 &_swigt__p_wxPropagateOnce,
58727 &_swigt__p_wxPropagationDisabler,
58728 &_swigt__p_wxPyApp,
58729 &_swigt__p_wxPyCommandEvent,
58730 &_swigt__p_wxPyDropTarget,
58731 &_swigt__p_wxPyEvent,
58732 &_swigt__p_wxPyFileSystemHandler,
58733 &_swigt__p_wxPyImageHandler,
58734 &_swigt__p_wxPyInputStream,
58735 &_swigt__p_wxPySizer,
58736 &_swigt__p_wxPyValidator,
58737 &_swigt__p_wxQuantize,
58738 &_swigt__p_wxQueryNewPaletteEvent,
58739 &_swigt__p_wxRealPoint,
58740 &_swigt__p_wxRect,
58741 &_swigt__p_wxRect2D,
58742 &_swigt__p_wxRegion,
58743 &_swigt__p_wxScrollEvent,
58744 &_swigt__p_wxScrollWinEvent,
58745 &_swigt__p_wxSetCursorEvent,
58746 &_swigt__p_wxShowEvent,
58747 &_swigt__p_wxSize,
58748 &_swigt__p_wxSizeEvent,
58749 &_swigt__p_wxSizer,
58750 &_swigt__p_wxSizerItem,
58751 &_swigt__p_wxStaticBox,
58752 &_swigt__p_wxStaticBoxSizer,
58753 &_swigt__p_wxStdDialogButtonSizer,
58754 &_swigt__p_wxSysColourChangedEvent,
58755 &_swigt__p_wxTIFFHandler,
58756 &_swigt__p_wxToolTip,
58757 &_swigt__p_wxUpdateUIEvent,
58758 &_swigt__p_wxValidator,
58759 &_swigt__p_wxVisualAttributes,
58760 &_swigt__p_wxWindow,
58761 &_swigt__p_wxWindowCreateEvent,
58762 &_swigt__p_wxWindowDestroyEvent,
58763 &_swigt__p_wxXPMHandler,
58764 &_swigt__p_wxZipFSHandler,
58765 };
58766
58767 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58775 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58776 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58777 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58778 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58781 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}};
58782 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58783 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}};
58784 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58785 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}};
58786 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 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}};
58794 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58807 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}};
58808 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58810 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}};
58811 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}};
58812 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58820 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}};
58821 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58822 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}};
58823 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58826 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}};
58827 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58834 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}};
58835 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58879 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58885 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}};
58886 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}};
58887 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58894 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}};
58895 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58896 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}};
58897 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58901
58902 static swig_cast_info *swig_cast_initial[] = {
58903 _swigc__p_buffer,
58904 _swigc__p_char,
58905 _swigc__p_form_ops_t,
58906 _swigc__p_int,
58907 _swigc__p_long,
58908 _swigc__p_unsigned_char,
58909 _swigc__p_unsigned_int,
58910 _swigc__p_unsigned_long,
58911 _swigc__p_wxANIHandler,
58912 _swigc__p_wxAcceleratorEntry,
58913 _swigc__p_wxAcceleratorTable,
58914 _swigc__p_wxActivateEvent,
58915 _swigc__p_wxAppTraits,
58916 _swigc__p_wxArrayString,
58917 _swigc__p_wxBMPHandler,
58918 _swigc__p_wxBitmap,
58919 _swigc__p_wxBoxSizer,
58920 _swigc__p_wxButton,
58921 _swigc__p_wxCURHandler,
58922 _swigc__p_wxCaret,
58923 _swigc__p_wxChildFocusEvent,
58924 _swigc__p_wxClipboardTextEvent,
58925 _swigc__p_wxCloseEvent,
58926 _swigc__p_wxColour,
58927 _swigc__p_wxCommandEvent,
58928 _swigc__p_wxContextMenuEvent,
58929 _swigc__p_wxControl,
58930 _swigc__p_wxControlWithItems,
58931 _swigc__p_wxCursor,
58932 _swigc__p_wxDC,
58933 _swigc__p_wxDateEvent,
58934 _swigc__p_wxDateTime,
58935 _swigc__p_wxDisplayChangedEvent,
58936 _swigc__p_wxDouble,
58937 _swigc__p_wxDropFilesEvent,
58938 _swigc__p_wxDuplexMode,
58939 _swigc__p_wxEraseEvent,
58940 _swigc__p_wxEvent,
58941 _swigc__p_wxEventLoop,
58942 _swigc__p_wxEventLoopActivator,
58943 _swigc__p_wxEvtHandler,
58944 _swigc__p_wxFSFile,
58945 _swigc__p_wxFileSystem,
58946 _swigc__p_wxFileSystemHandler,
58947 _swigc__p_wxFlexGridSizer,
58948 _swigc__p_wxFocusEvent,
58949 _swigc__p_wxFont,
58950 _swigc__p_wxFrame,
58951 _swigc__p_wxGBPosition,
58952 _swigc__p_wxGBSizerItem,
58953 _swigc__p_wxGBSpan,
58954 _swigc__p_wxGIFHandler,
58955 _swigc__p_wxGridBagSizer,
58956 _swigc__p_wxGridSizer,
58957 _swigc__p_wxHelpEvent__Origin,
58958 _swigc__p_wxICOHandler,
58959 _swigc__p_wxIconizeEvent,
58960 _swigc__p_wxIdleEvent,
58961 _swigc__p_wxImage,
58962 _swigc__p_wxImageHandler,
58963 _swigc__p_wxImageHistogram,
58964 _swigc__p_wxImage_HSVValue,
58965 _swigc__p_wxImage_RGBValue,
58966 _swigc__p_wxIndividualLayoutConstraint,
58967 _swigc__p_wxInitDialogEvent,
58968 _swigc__p_wxInputStream,
58969 _swigc__p_wxInternetFSHandler,
58970 _swigc__p_wxItemContainer,
58971 _swigc__p_wxJPEGHandler,
58972 _swigc__p_wxKeyEvent,
58973 _swigc__p_wxLayoutConstraints,
58974 _swigc__p_wxMaximizeEvent,
58975 _swigc__p_wxMemoryFSHandler,
58976 _swigc__p_wxMenu,
58977 _swigc__p_wxMenuBar,
58978 _swigc__p_wxMenuBarBase,
58979 _swigc__p_wxMenuEvent,
58980 _swigc__p_wxMenuItem,
58981 _swigc__p_wxMouseCaptureChangedEvent,
58982 _swigc__p_wxMouseCaptureLostEvent,
58983 _swigc__p_wxMouseEvent,
58984 _swigc__p_wxMoveEvent,
58985 _swigc__p_wxNavigationKeyEvent,
58986 _swigc__p_wxNcPaintEvent,
58987 _swigc__p_wxNotifyEvent,
58988 _swigc__p_wxObject,
58989 _swigc__p_wxOutputStream,
58990 _swigc__p_wxPCXHandler,
58991 _swigc__p_wxPNGHandler,
58992 _swigc__p_wxPNMHandler,
58993 _swigc__p_wxPaintEvent,
58994 _swigc__p_wxPaletteChangedEvent,
58995 _swigc__p_wxPaperSize,
58996 _swigc__p_wxPoint,
58997 _swigc__p_wxPoint2D,
58998 _swigc__p_wxPropagateOnce,
58999 _swigc__p_wxPropagationDisabler,
59000 _swigc__p_wxPyApp,
59001 _swigc__p_wxPyCommandEvent,
59002 _swigc__p_wxPyDropTarget,
59003 _swigc__p_wxPyEvent,
59004 _swigc__p_wxPyFileSystemHandler,
59005 _swigc__p_wxPyImageHandler,
59006 _swigc__p_wxPyInputStream,
59007 _swigc__p_wxPySizer,
59008 _swigc__p_wxPyValidator,
59009 _swigc__p_wxQuantize,
59010 _swigc__p_wxQueryNewPaletteEvent,
59011 _swigc__p_wxRealPoint,
59012 _swigc__p_wxRect,
59013 _swigc__p_wxRect2D,
59014 _swigc__p_wxRegion,
59015 _swigc__p_wxScrollEvent,
59016 _swigc__p_wxScrollWinEvent,
59017 _swigc__p_wxSetCursorEvent,
59018 _swigc__p_wxShowEvent,
59019 _swigc__p_wxSize,
59020 _swigc__p_wxSizeEvent,
59021 _swigc__p_wxSizer,
59022 _swigc__p_wxSizerItem,
59023 _swigc__p_wxStaticBox,
59024 _swigc__p_wxStaticBoxSizer,
59025 _swigc__p_wxStdDialogButtonSizer,
59026 _swigc__p_wxSysColourChangedEvent,
59027 _swigc__p_wxTIFFHandler,
59028 _swigc__p_wxToolTip,
59029 _swigc__p_wxUpdateUIEvent,
59030 _swigc__p_wxValidator,
59031 _swigc__p_wxVisualAttributes,
59032 _swigc__p_wxWindow,
59033 _swigc__p_wxWindowCreateEvent,
59034 _swigc__p_wxWindowDestroyEvent,
59035 _swigc__p_wxXPMHandler,
59036 _swigc__p_wxZipFSHandler,
59037 };
59038
59039
59040 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59041
59042 static swig_const_info swig_const_table[] = {
59043 {0, 0, 0, 0.0, 0, 0}};
59044
59045 #ifdef __cplusplus
59046 }
59047 #endif
59048 /* -----------------------------------------------------------------------------
59049 * Type initialization:
59050 * This problem is tough by the requirement that no dynamic
59051 * memory is used. Also, since swig_type_info structures store pointers to
59052 * swig_cast_info structures and swig_cast_info structures store pointers back
59053 * to swig_type_info structures, we need some lookup code at initialization.
59054 * The idea is that swig generates all the structures that are needed.
59055 * The runtime then collects these partially filled structures.
59056 * The SWIG_InitializeModule function takes these initial arrays out of
59057 * swig_module, and does all the lookup, filling in the swig_module.types
59058 * array with the correct data and linking the correct swig_cast_info
59059 * structures together.
59060 *
59061 * The generated swig_type_info structures are assigned staticly to an initial
59062 * array. We just loop though that array, and handle each type individually.
59063 * First we lookup if this type has been already loaded, and if so, use the
59064 * loaded structure instead of the generated one. Then we have to fill in the
59065 * cast linked list. The cast data is initially stored in something like a
59066 * two-dimensional array. Each row corresponds to a type (there are the same
59067 * number of rows as there are in the swig_type_initial array). Each entry in
59068 * a column is one of the swig_cast_info structures for that type.
59069 * The cast_initial array is actually an array of arrays, because each row has
59070 * a variable number of columns. So to actually build the cast linked list,
59071 * we find the array of casts associated with the type, and loop through it
59072 * adding the casts to the list. The one last trick we need to do is making
59073 * sure the type pointer in the swig_cast_info struct is correct.
59074 *
59075 * First off, we lookup the cast->type name to see if it is already loaded.
59076 * There are three cases to handle:
59077 * 1) If the cast->type has already been loaded AND the type we are adding
59078 * casting info to has not been loaded (it is in this module), THEN we
59079 * replace the cast->type pointer with the type pointer that has already
59080 * been loaded.
59081 * 2) If BOTH types (the one we are adding casting info to, and the
59082 * cast->type) are loaded, THEN the cast info has already been loaded by
59083 * the previous module so we just ignore it.
59084 * 3) Finally, if cast->type has not already been loaded, then we add that
59085 * swig_cast_info to the linked list (because the cast->type) pointer will
59086 * be correct.
59087 * ----------------------------------------------------------------------------- */
59088
59089 #ifdef __cplusplus
59090 extern "C" {
59091 #if 0
59092 } /* c-mode */
59093 #endif
59094 #endif
59095
59096 #if 0
59097 #define SWIGRUNTIME_DEBUG
59098 #endif
59099
59100 SWIGRUNTIME void
59101 SWIG_InitializeModule(void *clientdata) {
59102 size_t i;
59103 swig_module_info *module_head;
59104 static int init_run = 0;
59105
59106 clientdata = clientdata;
59107
59108 if (init_run) return;
59109 init_run = 1;
59110
59111 /* Initialize the swig_module */
59112 swig_module.type_initial = swig_type_initial;
59113 swig_module.cast_initial = swig_cast_initial;
59114
59115 /* Try and load any already created modules */
59116 module_head = SWIG_GetModule(clientdata);
59117 if (module_head) {
59118 swig_module.next = module_head->next;
59119 module_head->next = &swig_module;
59120 } else {
59121 /* This is the first module loaded */
59122 swig_module.next = &swig_module;
59123 SWIG_SetModule(clientdata, &swig_module);
59124 }
59125
59126 /* Now work on filling in swig_module.types */
59127 #ifdef SWIGRUNTIME_DEBUG
59128 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59129 #endif
59130 for (i = 0; i < swig_module.size; ++i) {
59131 swig_type_info *type = 0;
59132 swig_type_info *ret;
59133 swig_cast_info *cast;
59134
59135 #ifdef SWIGRUNTIME_DEBUG
59136 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59137 #endif
59138
59139 /* if there is another module already loaded */
59140 if (swig_module.next != &swig_module) {
59141 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59142 }
59143 if (type) {
59144 /* Overwrite clientdata field */
59145 #ifdef SWIGRUNTIME_DEBUG
59146 printf("SWIG_InitializeModule: found type %s\n", type->name);
59147 #endif
59148 if (swig_module.type_initial[i]->clientdata) {
59149 type->clientdata = swig_module.type_initial[i]->clientdata;
59150 #ifdef SWIGRUNTIME_DEBUG
59151 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59152 #endif
59153 }
59154 } else {
59155 type = swig_module.type_initial[i];
59156 }
59157
59158 /* Insert casting types */
59159 cast = swig_module.cast_initial[i];
59160 while (cast->type) {
59161 /* Don't need to add information already in the list */
59162 ret = 0;
59163 #ifdef SWIGRUNTIME_DEBUG
59164 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59165 #endif
59166 if (swig_module.next != &swig_module) {
59167 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59168 #ifdef SWIGRUNTIME_DEBUG
59169 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59170 #endif
59171 }
59172 if (ret) {
59173 if (type == swig_module.type_initial[i]) {
59174 #ifdef SWIGRUNTIME_DEBUG
59175 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59176 #endif
59177 cast->type = ret;
59178 ret = 0;
59179 } else {
59180 /* Check for casting already in the list */
59181 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59182 #ifdef SWIGRUNTIME_DEBUG
59183 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59184 #endif
59185 if (!ocast) ret = 0;
59186 }
59187 }
59188
59189 if (!ret) {
59190 #ifdef SWIGRUNTIME_DEBUG
59191 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59192 #endif
59193 if (type->cast) {
59194 type->cast->prev = cast;
59195 cast->next = type->cast;
59196 }
59197 type->cast = cast;
59198 }
59199 cast++;
59200 }
59201 /* Set entry in modules->types array equal to the type */
59202 swig_module.types[i] = type;
59203 }
59204 swig_module.types[i] = 0;
59205
59206 #ifdef SWIGRUNTIME_DEBUG
59207 printf("**** SWIG_InitializeModule: Cast List ******\n");
59208 for (i = 0; i < swig_module.size; ++i) {
59209 int j = 0;
59210 swig_cast_info *cast = swig_module.cast_initial[i];
59211 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59212 while (cast->type) {
59213 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59214 cast++;
59215 ++j;
59216 }
59217 printf("---- Total casts: %d\n",j);
59218 }
59219 printf("**** SWIG_InitializeModule: Cast List ******\n");
59220 #endif
59221 }
59222
59223 /* This function will propagate the clientdata field of type to
59224 * any new swig_type_info structures that have been added into the list
59225 * of equivalent types. It is like calling
59226 * SWIG_TypeClientData(type, clientdata) a second time.
59227 */
59228 SWIGRUNTIME void
59229 SWIG_PropagateClientData(void) {
59230 size_t i;
59231 swig_cast_info *equiv;
59232 static int init_run = 0;
59233
59234 if (init_run) return;
59235 init_run = 1;
59236
59237 for (i = 0; i < swig_module.size; i++) {
59238 if (swig_module.types[i]->clientdata) {
59239 equiv = swig_module.types[i]->cast;
59240 while (equiv) {
59241 if (!equiv->converter) {
59242 if (equiv->type && !equiv->type->clientdata)
59243 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59244 }
59245 equiv = equiv->next;
59246 }
59247 }
59248 }
59249 }
59250
59251 #ifdef __cplusplus
59252 #if 0
59253 {
59254 /* c-mode */
59255 #endif
59256 }
59257 #endif
59258
59259
59260
59261 #ifdef __cplusplus
59262 extern "C" {
59263 #endif
59264
59265 /* Python-specific SWIG API */
59266 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59267 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59268 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59269
59270 /* -----------------------------------------------------------------------------
59271 * global variable support code.
59272 * ----------------------------------------------------------------------------- */
59273
59274 typedef struct swig_globalvar {
59275 char *name; /* Name of global variable */
59276 PyObject *(*get_attr)(void); /* Return the current value */
59277 int (*set_attr)(PyObject *); /* Set the value */
59278 struct swig_globalvar *next;
59279 } swig_globalvar;
59280
59281 typedef struct swig_varlinkobject {
59282 PyObject_HEAD
59283 swig_globalvar *vars;
59284 } swig_varlinkobject;
59285
59286 SWIGINTERN PyObject *
59287 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59288 return PyString_FromString("<Swig global variables>");
59289 }
59290
59291 SWIGINTERN PyObject *
59292 swig_varlink_str(swig_varlinkobject *v) {
59293 PyObject *str = PyString_FromString("(");
59294 swig_globalvar *var;
59295 for (var = v->vars; var; var=var->next) {
59296 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59297 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59298 }
59299 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59300 return str;
59301 }
59302
59303 SWIGINTERN int
59304 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59305 PyObject *str = swig_varlink_str(v);
59306 fprintf(fp,"Swig global variables ");
59307 fprintf(fp,"%s\n", PyString_AsString(str));
59308 Py_DECREF(str);
59309 return 0;
59310 }
59311
59312 SWIGINTERN void
59313 swig_varlink_dealloc(swig_varlinkobject *v) {
59314 swig_globalvar *var = v->vars;
59315 while (var) {
59316 swig_globalvar *n = var->next;
59317 free(var->name);
59318 free(var);
59319 var = n;
59320 }
59321 }
59322
59323 SWIGINTERN PyObject *
59324 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59325 PyObject *res = NULL;
59326 swig_globalvar *var = v->vars;
59327 while (var) {
59328 if (strcmp(var->name,n) == 0) {
59329 res = (*var->get_attr)();
59330 break;
59331 }
59332 var = var->next;
59333 }
59334 if (res == NULL && !PyErr_Occurred()) {
59335 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59336 }
59337 return res;
59338 }
59339
59340 SWIGINTERN int
59341 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59342 int res = 1;
59343 swig_globalvar *var = v->vars;
59344 while (var) {
59345 if (strcmp(var->name,n) == 0) {
59346 res = (*var->set_attr)(p);
59347 break;
59348 }
59349 var = var->next;
59350 }
59351 if (res == 1 && !PyErr_Occurred()) {
59352 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59353 }
59354 return res;
59355 }
59356
59357 SWIGINTERN PyTypeObject*
59358 swig_varlink_type(void) {
59359 static char varlink__doc__[] = "Swig var link object";
59360 static PyTypeObject varlink_type;
59361 static int type_init = 0;
59362 if (!type_init) {
59363 const PyTypeObject tmp
59364 = {
59365 PyObject_HEAD_INIT(NULL)
59366 0, /* Number of items in variable part (ob_size) */
59367 (char *)"swigvarlink", /* Type name (tp_name) */
59368 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59369 0, /* Itemsize (tp_itemsize) */
59370 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59371 (printfunc) swig_varlink_print, /* Print (tp_print) */
59372 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59373 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59374 0, /* tp_compare */
59375 (reprfunc) swig_varlink_repr, /* tp_repr */
59376 0, /* tp_as_number */
59377 0, /* tp_as_sequence */
59378 0, /* tp_as_mapping */
59379 0, /* tp_hash */
59380 0, /* tp_call */
59381 (reprfunc)swig_varlink_str, /* tp_str */
59382 0, /* tp_getattro */
59383 0, /* tp_setattro */
59384 0, /* tp_as_buffer */
59385 0, /* tp_flags */
59386 varlink__doc__, /* tp_doc */
59387 0, /* tp_traverse */
59388 0, /* tp_clear */
59389 0, /* tp_richcompare */
59390 0, /* tp_weaklistoffset */
59391 #if PY_VERSION_HEX >= 0x02020000
59392 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59393 #endif
59394 #if PY_VERSION_HEX >= 0x02030000
59395 0, /* tp_del */
59396 #endif
59397 #ifdef COUNT_ALLOCS
59398 0,0,0,0 /* tp_alloc -> tp_next */
59399 #endif
59400 };
59401 varlink_type = tmp;
59402 varlink_type.ob_type = &PyType_Type;
59403 type_init = 1;
59404 }
59405 return &varlink_type;
59406 }
59407
59408 /* Create a variable linking object for use later */
59409 SWIGINTERN PyObject *
59410 SWIG_Python_newvarlink(void) {
59411 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59412 if (result) {
59413 result->vars = 0;
59414 }
59415 return ((PyObject*) result);
59416 }
59417
59418 SWIGINTERN void
59419 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59420 swig_varlinkobject *v = (swig_varlinkobject *) p;
59421 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59422 if (gv) {
59423 size_t size = strlen(name)+1;
59424 gv->name = (char *)malloc(size);
59425 if (gv->name) {
59426 strncpy(gv->name,name,size);
59427 gv->get_attr = get_attr;
59428 gv->set_attr = set_attr;
59429 gv->next = v->vars;
59430 }
59431 }
59432 v->vars = gv;
59433 }
59434
59435 SWIGINTERN PyObject *
59436 SWIG_globals() {
59437 static PyObject *_SWIG_globals = 0;
59438 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59439 return _SWIG_globals;
59440 }
59441
59442 /* -----------------------------------------------------------------------------
59443 * constants/methods manipulation
59444 * ----------------------------------------------------------------------------- */
59445
59446 /* Install Constants */
59447 SWIGINTERN void
59448 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59449 PyObject *obj = 0;
59450 size_t i;
59451 for (i = 0; constants[i].type; ++i) {
59452 switch(constants[i].type) {
59453 case SWIG_PY_POINTER:
59454 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59455 break;
59456 case SWIG_PY_BINARY:
59457 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59458 break;
59459 default:
59460 obj = 0;
59461 break;
59462 }
59463 if (obj) {
59464 PyDict_SetItemString(d, constants[i].name, obj);
59465 Py_DECREF(obj);
59466 }
59467 }
59468 }
59469
59470 /* -----------------------------------------------------------------------------*/
59471 /* Fix SwigMethods to carry the callback ptrs when needed */
59472 /* -----------------------------------------------------------------------------*/
59473
59474 SWIGINTERN void
59475 SWIG_Python_FixMethods(PyMethodDef *methods,
59476 swig_const_info *const_table,
59477 swig_type_info **types,
59478 swig_type_info **types_initial) {
59479 size_t i;
59480 for (i = 0; methods[i].ml_name; ++i) {
59481 const char *c = methods[i].ml_doc;
59482 if (c && (c = strstr(c, "swig_ptr: "))) {
59483 int j;
59484 swig_const_info *ci = 0;
59485 const char *name = c + 10;
59486 for (j = 0; const_table[j].type; ++j) {
59487 if (strncmp(const_table[j].name, name,
59488 strlen(const_table[j].name)) == 0) {
59489 ci = &(const_table[j]);
59490 break;
59491 }
59492 }
59493 if (ci) {
59494 size_t shift = (ci->ptype) - types;
59495 swig_type_info *ty = types_initial[shift];
59496 size_t ldoc = (c - methods[i].ml_doc);
59497 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59498 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59499 if (ndoc) {
59500 char *buff = ndoc;
59501 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59502 if (ptr) {
59503 strncpy(buff, methods[i].ml_doc, ldoc);
59504 buff += ldoc;
59505 strncpy(buff, "swig_ptr: ", 10);
59506 buff += 10;
59507 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59508 methods[i].ml_doc = ndoc;
59509 }
59510 }
59511 }
59512 }
59513 }
59514 }
59515
59516 #ifdef __cplusplus
59517 }
59518 #endif
59519
59520 /* -----------------------------------------------------------------------------*
59521 * Partial Init method
59522 * -----------------------------------------------------------------------------*/
59523
59524 #ifdef __cplusplus
59525 extern "C"
59526 #endif
59527 SWIGEXPORT void SWIG_init(void) {
59528 PyObject *m, *d;
59529
59530 /* Fix SwigMethods to carry the callback ptrs when needed */
59531 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59532
59533 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59534 d = PyModule_GetDict(m);
59535
59536 SWIG_InitializeModule(0);
59537 SWIG_InstallConstants(d,swig_const_table);
59538
59539
59540
59541 #ifndef wxPyUSE_EXPORT
59542 // Make our API structure a CObject so other modules can import it
59543 // from this module.
59544 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59545 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59546 Py_XDECREF(cobj);
59547 #endif
59548
59549 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59550 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59551 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59552 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59553 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59554 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59555 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59556 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59557 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59558 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59559 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59560 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59561 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59562 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59563 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59564 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59565 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59566 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59567 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59568 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59569 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59570 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59571 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59572 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59573 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59574 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59575 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59576 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59577 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59578 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59579 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59580 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59581 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59582 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59583 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59584 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59585 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59586 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59587 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59588 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59589 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59590 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59591 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59592 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59593 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59594 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59595 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59596 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59597 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59598 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59599 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59600 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59601 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59602 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59603 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59604 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59605 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59606 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59607 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59608 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59609 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59610 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59611 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59612 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59613 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59614 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59615 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59616 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59617 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59618 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59619 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59620 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59621 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59622 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59623 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59624 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59625 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59626 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59627 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59628 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59629 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59630 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59631 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59632 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59633 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59634 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59635 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59636 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59637 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59638 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59639 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59640 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59641 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59642 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59643 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59644 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59645 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59646 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59647 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59648 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59649 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59650 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59651 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59652 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59653 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59654 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59655 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59656 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59657 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59658 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59659 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59660 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59661 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59662 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59663 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59664 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59665 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59666 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59667 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59668 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59669 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59670 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59671 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59672 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59673 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59674 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59675 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59676 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59677 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59678 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59679 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59680 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59681 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59682 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59683 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59684 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59685 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59686 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59687 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59688 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59689 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59690 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59691 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59692 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59693 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59694 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59695 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59696 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59697 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59698 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59699 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59700 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59701 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59702 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59703 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59704 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59705 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59706 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59707 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59708 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59709 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59710 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59711 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59712 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59713 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59714 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59715 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59716 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59717 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59718 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59719 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59720 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59721 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59722 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59723 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59724 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59725 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59726 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59727 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59728 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59729 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59730 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59731 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59732 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59733 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59734 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59735 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59736 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59737 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59738 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59739 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59740 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59741 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59742 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59743 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59744 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59745 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59746 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59747 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59748 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59749 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59750 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59751 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59752 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59753 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59754 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59755 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59756 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59757 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59758 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59759 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59760 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59761 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59762 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59763 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59764 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59765 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59766 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59767 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59768 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59769 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59770 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59771 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59772 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59773 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59774 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59775 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59776 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59777 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59778 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59779 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59780 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59781 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59782 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59783 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59784 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59785 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59786 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59787 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59788 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59789 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59790 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59791 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59792 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59793 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59794 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59795 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59796 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59797 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59798 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59799 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59800 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59801 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59802 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59803 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59804 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59805 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59806 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59807 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59808 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59809 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59810 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59811 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59812 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59813 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59814 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59815 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59816 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59817 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59818 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59819 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59820 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59821 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59822 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59823 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59824 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59825 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59826 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59827 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59828 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59829 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59830 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59831 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59832 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59833 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59834 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59835 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59836 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59837 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59838 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59839 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59840 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59841 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59842 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59843 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59844 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59845 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59846 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59847 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59848 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59849 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59850 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59851 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59852 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59853 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59854 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59855 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59856 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59857 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59858 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59859 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59860 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59861 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59862 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59863 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59864 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59865 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59866 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59867 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59868 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59869 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59870 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59871 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59872 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59873 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59874 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59875 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59876 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59877 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59878 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59879 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59880 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59881 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59882 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59883 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59884 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59885 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59886 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59887 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59888 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59889 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59890 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59891 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59892 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59893 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59894 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59895 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59896 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59897 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59898 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59899 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59909 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59910 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59911 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59912 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59913 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59914 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59915 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59916 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59917 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59918 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59919 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59920 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59921 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59922 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59923 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59924 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59925 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59926 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59927 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59928 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59929 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59930 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59931 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59932 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59933 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59934 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59935 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59936 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59937 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59938 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59939 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59940 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59941 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59942 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59943 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59944 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59945 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59946 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59947 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59948 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59949 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59951 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59952 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59956 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59957 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59958 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59959 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59970 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59971 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59972 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59973 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59974 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59975 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59976 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59977 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59978 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59979 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59980 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59981 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59982 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59983 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59984 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59985 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59986 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59987 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59988 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59989 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59990 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59991 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59992 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59993 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59994 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59995 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59996 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59997 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59998 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59999 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60000 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60001 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60002 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60003 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60004 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60005 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60006 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60007 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60008 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60009 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60010 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60011 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60012 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60013 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60014 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60015 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60016 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60017 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60018 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60019 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60020 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60021 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60022 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60023 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60024 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60025 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60026 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60027 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60028 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60029 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60030 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60031 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60032 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60033 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60034 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60035 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60036 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60037 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60038 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60039 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60040 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60041 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60042 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60043 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60044 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60045 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60046 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60047 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60048 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60049 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60050 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60051 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60052 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60053 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60054 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60055 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60056 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60057 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60058 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60059 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60060 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60061 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60062 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60063 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60064 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60065 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60066 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60067 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60068 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60069 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60070 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60071 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60072 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60073 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60074 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60075 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60076 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60077 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60078 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60079 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60080 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60081 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60082 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60083 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60084 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60085 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60086 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60087 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60088 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60089 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60090 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60091 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60092 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60093 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60094 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60095 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60096 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60097 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60098 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60099 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60100 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60101 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60102 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60103 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60104 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60105 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60106 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60107 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60108 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60109 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60110 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60111 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60112 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60113 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60114 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60115 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60116 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60117 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60118 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60119 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60120 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60121 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60122 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60123 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60124 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60125 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60126 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60127 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60128 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60129 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60130 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60131 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60132 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60133 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60134 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60135 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60136 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60137 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60138 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60139 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60140 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60141 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60142 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60143 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60144 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60145 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60146 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60147 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60148 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60149 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60150 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60151 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60152 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60153 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60154 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60155 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60156 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60157 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60158 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60159 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60160 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60161 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60162 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60163 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60164 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60165 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60166 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60173 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60174 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60175 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60176 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60177 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60178 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60179 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60180 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60181 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60182 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60183 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60184 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60185 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60186 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60187 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60188 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60189 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60190 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60191 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60192 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60193 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60194 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60195 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60196 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60197 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60198 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60199 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60200 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60201 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60202 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60203 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60204 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60205 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60206 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60207 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60208 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60209 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60210 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60211 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60212 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60213 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60214
60215 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60216
60217
60218 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60219
60220 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60221 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60222 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60223 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60224 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60225 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60226 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60227 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60228 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60229 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60230 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60231 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60232 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60233 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60234 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60235 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60236 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60237 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60238 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60239 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60240 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60241 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60242 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60243 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60244 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60245 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60246 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60247 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60248 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60249 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60250 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60251 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60252 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60253 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60254 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60255 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60256 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60257 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60258 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60259 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60260 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60261 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60262 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60263 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60264 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60265 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60266 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60267 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60268 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60269 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60270 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60271 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60272 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60273 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60274 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60275 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60276 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60277 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60278 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60279 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60280 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60281 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60282 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60283 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60284 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60285 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60286 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60287 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60288 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60289 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60290 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60291 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60292 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60293 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60294 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60295 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60296 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60297 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60298 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60299 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60300 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60301 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60302 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60303 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60304 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60305 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60306 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60307 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60308 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60309 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60310 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60311 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60312 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60313 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60314 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60315 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60316 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60317 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60318 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60319 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60320 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60321 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60322 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60323 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60324 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60325 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60326 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60327 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60328 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60329 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60330 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60331 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60332 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60333 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60334 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60335 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60336 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60337 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60338 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60339 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60340 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60341 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60342 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60343 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60344 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60345 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60346 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60347 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60348 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60349 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60350 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60351 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60352 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60353 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60354 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60355 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60356 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60357 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60358 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60359 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60360 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60361 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60362 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60363 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60364 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60365 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60366 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60367 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60368 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60369 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60370 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60371 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60372 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60373 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60374 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60375 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60376 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60377 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60378 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60379 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60380 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60381 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60382 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60383 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60384 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60385 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60386 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60387 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60388 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60389 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60390 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60391 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60392 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60393 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60394 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60395 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60396 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60397 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60398 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60399 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60400 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60401 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60402 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60403 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60404 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60405 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60406 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60407 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60408 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60409 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60410 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60411 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60412 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60413 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60414 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60415 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60416 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60417 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60418 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60419 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60420 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60421 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60422 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60423 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60424 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60425 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60426 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60427 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60428 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60429 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60430 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60431 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60432 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60433 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60434
60435 // Initialize threading, some globals and such
60436 __wxPyPreStart(d);
60437
60438
60439 // Although these are defined in __version__ they need to be here too so
60440 // that an assert can be done to ensure that the wxPython and the wxWindows
60441 // versions match.
60442 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60443 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60444 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60445
60446 }
60447
wxWidgets (Impactor)