]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
aui docking works well on systems with solid window dragging turned off
[wxWidgets.git] / wxPython / src / gtk / _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 bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3884 #if wxUSE_HOTKEY
3885 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3886 #else
3887 return false;
3888 #endif
3889 }
3890 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3891
3892
3893
3894 return false;
3895
3896 }
3897 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3898 return wxPyGetWinHandle(self);
3899 }
3900 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3901 self->AssociateHandle((WXWidget)handle);
3902 }
3903 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3904
3905 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3906 return wxWindow::FindWindowById(id, parent);
3907 }
3908
3909 wxWindow* wxFindWindowByName( const wxString& name,
3910 const wxWindow *parent = NULL ) {
3911 return wxWindow::FindWindowByName(name, parent);
3912 }
3913
3914 wxWindow* wxFindWindowByLabel( const wxString& label,
3915 const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowByLabel(label, parent);
3917 }
3918
3919
3920 #ifdef __WXMSW__
3921 #include <wx/msw/private.h> // to get wxGetWindowId
3922 #endif
3923
3924
3925 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3926 #ifdef __WXMSW__
3927 WXHWND hWnd = (WXHWND)_hWnd;
3928 long id = wxGetWindowId(hWnd);
3929 wxWindow* win = new wxWindow;
3930 if (parent)
3931 parent->AddChild(win);
3932 win->SetEventHandler(win);
3933 win->SetHWND(hWnd);
3934 win->SetId(id);
3935 win->SubclassWin(hWnd);
3936 win->AdoptAttributesFromHWND();
3937 win->SetupColours();
3938 return win;
3939 #else
3940 wxPyRaiseNotImplemented();
3941 return NULL;
3942 #endif
3943 }
3944
3945
3946 PyObject* GetTopLevelWindows() {
3947 return wxPy_ConvertList(&wxTopLevelWindows);
3948 }
3949
3950
3951 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3952 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3953 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3954
3955 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3956
3957
3958 SWIGINTERNINLINE int
3959 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3960 {
3961 unsigned long v;
3962 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3963 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3964 return res;
3965 }
3966
3967 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3968 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3969 wxMenuItemList& list = self->GetMenuItems();
3970 return wxPy_ConvertList(&list);
3971 }
3972 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3973 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3974 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3975 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3976 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3977 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3978 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3979 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3980 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3981 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3982 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3983 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3984 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3985 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3986 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3987 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3988 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3989 static const wxString wxPyControlNameStr(wxControlNameStr);
3990 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3991 if (clientData) {
3992 wxPyClientData* data = new wxPyClientData(clientData);
3993 return self->Append(item, data);
3994 } else
3995 return self->Append(item);
3996 }
3997 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3998 if (clientData) {
3999 wxPyClientData* data = new wxPyClientData(clientData);
4000 return self->Insert(item, pos, data);
4001 } else
4002 return self->Insert(item, pos);
4003 }
4004 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4005 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4006 if (data) {
4007 Py_INCREF(data->m_obj);
4008 return data->m_obj;
4009 } else {
4010 Py_INCREF(Py_None);
4011 return Py_None;
4012 }
4013 }
4014 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4015 wxPyClientData* data = new wxPyClientData(clientData);
4016 self->SetClientObject(n, data);
4017 }
4018
4019
4020 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4021 wxPyUserData* data = NULL;
4022 if ( userData ) {
4023 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4024 data = new wxPyUserData(userData);
4025 wxPyEndBlockThreads(blocked);
4026 }
4027 return new wxSizerItem(window, proportion, flag, border, data);
4028 }
4029 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4030 wxPyUserData* data = NULL;
4031 if ( userData ) {
4032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4033 data = new wxPyUserData(userData);
4034 wxPyEndBlockThreads(blocked);
4035 }
4036 return new wxSizerItem(width, height, proportion, flag, border, data);
4037 }
4038 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4039 wxPyUserData* data = NULL;
4040 if ( userData ) {
4041 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4042 data = new wxPyUserData(userData);
4043 wxPyEndBlockThreads(blocked);
4044 }
4045 return new wxSizerItem(sizer, proportion, flag, border, data);
4046 }
4047
4048 SWIGINTERNINLINE PyObject *
4049 SWIG_From_float (float value)
4050 {
4051 return SWIG_From_double (value);
4052 }
4053
4054 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4055 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4056 if (data) {
4057 Py_INCREF(data->m_obj);
4058 return data->m_obj;
4059 } else {
4060 Py_INCREF(Py_None);
4061 return Py_None;
4062 }
4063 }
4064 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4065 wxPyUserData* data = NULL;
4066 if ( userData ) {
4067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4068 data = new wxPyUserData(userData);
4069 wxPyEndBlockThreads(blocked);
4070 }
4071 self->SetUserData(data);
4072 }
4073
4074 // Figure out the type of the sizer item
4075
4076 struct wxPySizerItemInfo {
4077 wxPySizerItemInfo()
4078 : window(NULL), sizer(NULL), gotSize(false),
4079 size(wxDefaultSize), gotPos(false), pos(-1)
4080 {}
4081
4082 wxWindow* window;
4083 wxSizer* sizer;
4084 bool gotSize;
4085 wxSize size;
4086 bool gotPos;
4087 int pos;
4088 };
4089
4090 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4091
4092 wxPySizerItemInfo info;
4093 wxSize size;
4094 wxSize* sizePtr = &size;
4095
4096 // Find out what the type of the item is
4097 // try wxWindow
4098 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4099 PyErr_Clear();
4100 info.window = NULL;
4101
4102 // try wxSizer
4103 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4104 PyErr_Clear();
4105 info.sizer = NULL;
4106
4107 // try wxSize or (w,h)
4108 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4109 info.size = *sizePtr;
4110 info.gotSize = true;
4111 }
4112
4113 // or a single int
4114 if (checkIdx && PyInt_Check(item)) {
4115 info.pos = PyInt_AsLong(item);
4116 info.gotPos = true;
4117 }
4118 }
4119 }
4120
4121 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4122 // no expected type, figure out what kind of error message to generate
4123 if ( !checkSize && !checkIdx )
4124 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4125 else if ( checkSize && !checkIdx )
4126 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4127 else if ( !checkSize && checkIdx)
4128 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4129 else
4130 // can this one happen?
4131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4132 }
4133
4134 return info;
4135 }
4136
4137 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4138 if (!self->GetClientObject())
4139 self->SetClientObject(new wxPyOORClientData(_self));
4140 }
4141 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4142
4143 wxPyUserData* data = NULL;
4144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4145 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4146 if ( userData && (info.window || info.sizer || info.gotSize) )
4147 data = new wxPyUserData(userData);
4148 if ( info.sizer )
4149 PyObject_SetAttrString(item,"thisown",Py_False);
4150 wxPyEndBlockThreads(blocked);
4151
4152 // Now call the real Add method if a valid item type was found
4153 if ( info.window )
4154 return self->Add(info.window, proportion, flag, border, data);
4155 else if ( info.sizer )
4156 return self->Add(info.sizer, proportion, flag, border, data);
4157 else if (info.gotSize)
4158 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4159 proportion, flag, border, data);
4160 else
4161 return NULL;
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4164
4165 wxPyUserData* data = NULL;
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4168 if ( userData && (info.window || info.sizer || info.gotSize) )
4169 data = new wxPyUserData(userData);
4170 if ( info.sizer )
4171 PyObject_SetAttrString(item,"thisown",Py_False);
4172 wxPyEndBlockThreads(blocked);
4173
4174 // Now call the real Insert method if a valid item type was found
4175 if ( info.window )
4176 return self->Insert(before, info.window, proportion, flag, border, data);
4177 else if ( info.sizer )
4178 return self->Insert(before, info.sizer, proportion, flag, border, data);
4179 else if (info.gotSize)
4180 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4181 proportion, flag, border, data);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4186
4187 wxPyUserData* data = NULL;
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4190 if ( userData && (info.window || info.sizer || info.gotSize) )
4191 data = new wxPyUserData(userData);
4192 if ( info.sizer )
4193 PyObject_SetAttrString(item,"thisown",Py_False);
4194 wxPyEndBlockThreads(blocked);
4195
4196 // Now call the real Prepend method if a valid item type was found
4197 if ( info.window )
4198 return self->Prepend(info.window, proportion, flag, border, data);
4199 else if ( info.sizer )
4200 return self->Prepend(info.sizer, proportion, flag, border, data);
4201 else if (info.gotSize)
4202 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4203 proportion, flag, border, data);
4204 else
4205 return NULL;
4206 }
4207 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 return self->Remove(info.window);
4213 else if ( info.sizer )
4214 return self->Remove(info.sizer);
4215 else if ( info.gotPos )
4216 return self->Remove(info.pos);
4217 else
4218 return false;
4219 }
4220 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Detach(info.window);
4226 else if ( info.sizer )
4227 return self->Detach(info.sizer);
4228 else if ( info.gotPos )
4229 return self->Detach(info.pos);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->GetItem(info.window);
4239 else if ( info.sizer )
4240 return self->GetItem(info.sizer);
4241 else if ( info.gotPos )
4242 return self->GetItem(info.pos);
4243 else
4244 return NULL;
4245 }
4246 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4247 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4248 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4249 wxPyEndBlockThreads(blocked);
4250 if ( info.window )
4251 self->SetItemMinSize(info.window, size);
4252 else if ( info.sizer )
4253 self->SetItemMinSize(info.sizer, size);
4254 else if ( info.gotPos )
4255 self->SetItemMinSize(info.pos, size);
4256 }
4257 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4258 wxSizerItemList& list = self->GetChildren();
4259 return wxPy_ConvertList(&list);
4260 }
4261 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4262 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4263 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4264 wxPyEndBlockThreads(blocked);
4265 if ( info.window )
4266 return self->Show(info.window, show, recursive);
4267 else if ( info.sizer )
4268 return self->Show(info.sizer, show, recursive);
4269 else if ( info.gotPos )
4270 return self->Show(info.pos, show);
4271 else
4272 return false;
4273 }
4274 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4275 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4276 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4277 wxPyEndBlockThreads(blocked);
4278 if ( info.window )
4279 return self->IsShown(info.window);
4280 else if ( info.sizer )
4281 return self->IsShown(info.sizer);
4282 else if ( info.gotPos )
4283 return self->IsShown(info.pos);
4284 else
4285 return false;
4286 }
4287
4288 // See pyclasses.h
4289 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4290 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4291 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4292
4293
4294
4295
4296 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4297 {
4298 if (source == Py_None) {
4299 **obj = wxGBPosition(-1,-1);
4300 return true;
4301 }
4302 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4303 }
4304
4305 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4306 {
4307 if (source == Py_None) {
4308 **obj = wxGBSpan(-1,-1);
4309 return true;
4310 }
4311 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4312 }
4313
4314
4315 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4316 wxGBPosition temp, *obj = &temp;
4317 if ( other == Py_None ) return false;
4318 if ( ! wxGBPosition_helper(other, &obj) ) {
4319 PyErr_Clear();
4320 return false;
4321 }
4322 return self->operator==(*obj);
4323 }
4324 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4325 wxGBPosition temp, *obj = &temp;
4326 if ( other == Py_None ) return true;
4327 if ( ! wxGBPosition_helper(other, &obj)) {
4328 PyErr_Clear();
4329 return true;
4330 }
4331 return self->operator!=(*obj);
4332 }
4333 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4334 self->SetRow(row);
4335 self->SetCol(col);
4336 }
4337 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 PyObject* tup = PyTuple_New(2);
4340 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4341 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4342 wxPyEndBlockThreads(blocked);
4343 return tup;
4344 }
4345 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4346 wxGBSpan temp, *obj = &temp;
4347 if ( other == Py_None ) return false;
4348 if ( ! wxGBSpan_helper(other, &obj) ) {
4349 PyErr_Clear();
4350 return false;
4351 }
4352 return self->operator==(*obj);
4353 }
4354 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4355 wxGBSpan temp, *obj = &temp;
4356 if ( other == Py_None ) return true;
4357 if ( ! wxGBSpan_helper(other, &obj)) {
4358 PyErr_Clear();
4359 return true;
4360 }
4361 return self->operator!=(*obj);
4362 }
4363 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4364 self->SetRowspan(rowspan);
4365 self->SetColspan(colspan);
4366 }
4367 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4368 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4369 PyObject* tup = PyTuple_New(2);
4370 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4371 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4372 wxPyEndBlockThreads(blocked);
4373 return tup;
4374 }
4375 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4376 wxPyUserData* data = NULL;
4377 if ( userData ) {
4378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4379 data = new wxPyUserData(userData);
4380 wxPyEndBlockThreads(blocked);
4381 }
4382 return new wxGBSizerItem(window, pos, span, flag, border, data);
4383 }
4384 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4385 wxPyUserData* data = NULL;
4386 if ( userData ) {
4387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4388 data = new wxPyUserData(userData);
4389 wxPyEndBlockThreads(blocked);
4390 }
4391 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4392 }
4393 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4394 wxPyUserData* data = NULL;
4395 if ( userData ) {
4396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4397 data = new wxPyUserData(userData);
4398 wxPyEndBlockThreads(blocked);
4399 }
4400 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4401 }
4402 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4403 int row, col;
4404 self->GetEndPos(row, col);
4405 return wxGBPosition(row, col);
4406 }
4407 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4408
4409 wxPyUserData* data = NULL;
4410 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4411 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4412 if ( userData && (info.window || info.sizer || info.gotSize) )
4413 data = new wxPyUserData(userData);
4414 if ( info.sizer )
4415 PyObject_SetAttrString(item,"thisown",Py_False);
4416 wxPyEndBlockThreads(blocked);
4417
4418 // Now call the real Add method if a valid item type was found
4419 if ( info.window )
4420 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4421 else if ( info.sizer )
4422 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4423 else if (info.gotSize)
4424 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4425 pos, span, flag, border, data);
4426 return NULL;
4427 }
4428
4429
4430 #ifdef __cplusplus
4431 extern "C" {
4432 #endif
4433 SWIGINTERN int EmptyString_set(PyObject *) {
4434 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4435 return 1;
4436 }
4437
4438
4439 SWIGINTERN PyObject *EmptyString_get(void) {
4440 PyObject *pyobj = 0;
4441
4442 {
4443 #if wxUSE_UNICODE
4444 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4445 #else
4446 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4447 #endif
4448 }
4449 return pyobj;
4450 }
4451
4452
4453 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4454 PyObject *resultobj = 0;
4455 wxObject *arg1 = (wxObject *) 0 ;
4456 wxString result;
4457 void *argp1 = 0 ;
4458 int res1 = 0 ;
4459 PyObject *swig_obj[1] ;
4460
4461 if (!args) SWIG_fail;
4462 swig_obj[0] = args;
4463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4464 if (!SWIG_IsOK(res1)) {
4465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4466 }
4467 arg1 = reinterpret_cast< wxObject * >(argp1);
4468 {
4469 PyThreadState* __tstate = wxPyBeginAllowThreads();
4470 result = wxObject_GetClassName(arg1);
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 {
4475 #if wxUSE_UNICODE
4476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4477 #else
4478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4479 #endif
4480 }
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *resultobj = 0;
4489 wxObject *arg1 = (wxObject *) 0 ;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 PyObject *swig_obj[1] ;
4493
4494 if (!args) SWIG_fail;
4495 swig_obj[0] = args;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4499 }
4500 arg1 = reinterpret_cast< wxObject * >(argp1);
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 wxObject_Destroy(arg1);
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 resultobj = SWIG_Py_Void();
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4515 PyObject *resultobj = 0;
4516 wxObject *arg1 = (wxObject *) 0 ;
4517 wxObject *arg2 = 0 ;
4518 bool result;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 void *argp2 = 0 ;
4522 int res2 = 0 ;
4523 PyObject * obj0 = 0 ;
4524 PyObject * obj1 = 0 ;
4525 char * kwnames[] = {
4526 (char *) "self",(char *) "p", NULL
4527 };
4528
4529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4531 if (!SWIG_IsOK(res1)) {
4532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4533 }
4534 arg1 = reinterpret_cast< wxObject * >(argp1);
4535 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4536 if (!SWIG_IsOK(res2)) {
4537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4538 }
4539 if (!argp2) {
4540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4541 }
4542 arg2 = reinterpret_cast< wxObject * >(argp2);
4543 {
4544 PyThreadState* __tstate = wxPyBeginAllowThreads();
4545 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4559 PyObject *obj;
4560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4561 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4562 return SWIG_Py_Void();
4563 }
4564
4565 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxSize *arg1 = (wxSize *) 0 ;
4568 int arg2 ;
4569 void *argp1 = 0 ;
4570 int res1 = 0 ;
4571 int val2 ;
4572 int ecode2 = 0 ;
4573 PyObject *swig_obj[2] ;
4574
4575 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4582 if (!SWIG_IsOK(ecode2)) {
4583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4584 }
4585 arg2 = static_cast< int >(val2);
4586 if (arg1) (arg1)->x = arg2;
4587
4588 resultobj = SWIG_Py_Void();
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596 PyObject *resultobj = 0;
4597 wxSize *arg1 = (wxSize *) 0 ;
4598 int result;
4599 void *argp1 = 0 ;
4600 int res1 = 0 ;
4601 PyObject *swig_obj[1] ;
4602
4603 if (!args) SWIG_fail;
4604 swig_obj[0] = args;
4605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4606 if (!SWIG_IsOK(res1)) {
4607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4608 }
4609 arg1 = reinterpret_cast< wxSize * >(argp1);
4610 result = (int) ((arg1)->x);
4611 resultobj = SWIG_From_int(static_cast< int >(result));
4612 return resultobj;
4613 fail:
4614 return NULL;
4615 }
4616
4617
4618 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4619 PyObject *resultobj = 0;
4620 wxSize *arg1 = (wxSize *) 0 ;
4621 int arg2 ;
4622 void *argp1 = 0 ;
4623 int res1 = 0 ;
4624 int val2 ;
4625 int ecode2 = 0 ;
4626 PyObject *swig_obj[2] ;
4627
4628 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4630 if (!SWIG_IsOK(res1)) {
4631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4632 }
4633 arg1 = reinterpret_cast< wxSize * >(argp1);
4634 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4635 if (!SWIG_IsOK(ecode2)) {
4636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4637 }
4638 arg2 = static_cast< int >(val2);
4639 if (arg1) (arg1)->y = arg2;
4640
4641 resultobj = SWIG_Py_Void();
4642 return resultobj;
4643 fail:
4644 return NULL;
4645 }
4646
4647
4648 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4649 PyObject *resultobj = 0;
4650 wxSize *arg1 = (wxSize *) 0 ;
4651 int result;
4652 void *argp1 = 0 ;
4653 int res1 = 0 ;
4654 PyObject *swig_obj[1] ;
4655
4656 if (!args) SWIG_fail;
4657 swig_obj[0] = args;
4658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4661 }
4662 arg1 = reinterpret_cast< wxSize * >(argp1);
4663 result = (int) ((arg1)->y);
4664 resultobj = SWIG_From_int(static_cast< int >(result));
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 int arg1 = (int) 0 ;
4674 int arg2 = (int) 0 ;
4675 wxSize *result = 0 ;
4676 int val1 ;
4677 int ecode1 = 0 ;
4678 int val2 ;
4679 int ecode2 = 0 ;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 char * kwnames[] = {
4683 (char *) "w",(char *) "h", NULL
4684 };
4685
4686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4687 if (obj0) {
4688 ecode1 = SWIG_AsVal_int(obj0, &val1);
4689 if (!SWIG_IsOK(ecode1)) {
4690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4691 }
4692 arg1 = static_cast< int >(val1);
4693 }
4694 if (obj1) {
4695 ecode2 = SWIG_AsVal_int(obj1, &val2);
4696 if (!SWIG_IsOK(ecode2)) {
4697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4698 }
4699 arg2 = static_cast< int >(val2);
4700 }
4701 {
4702 result = (wxSize *)new wxSize(arg1,arg2);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 wxSize *arg1 = (wxSize *) 0 ;
4715 void *argp1 = 0 ;
4716 int res1 = 0 ;
4717 PyObject *swig_obj[1] ;
4718
4719 if (!args) SWIG_fail;
4720 swig_obj[0] = args;
4721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4722 if (!SWIG_IsOK(res1)) {
4723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4724 }
4725 arg1 = reinterpret_cast< wxSize * >(argp1);
4726 {
4727 delete arg1;
4728
4729 if (PyErr_Occurred()) SWIG_fail;
4730 }
4731 resultobj = SWIG_Py_Void();
4732 return resultobj;
4733 fail:
4734 return NULL;
4735 }
4736
4737
4738 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4739 PyObject *resultobj = 0;
4740 wxSize *arg1 = (wxSize *) 0 ;
4741 PyObject *arg2 = (PyObject *) 0 ;
4742 bool result;
4743 void *argp1 = 0 ;
4744 int res1 = 0 ;
4745 PyObject * obj0 = 0 ;
4746 PyObject * obj1 = 0 ;
4747 char * kwnames[] = {
4748 (char *) "self",(char *) "other", NULL
4749 };
4750
4751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4755 }
4756 arg1 = reinterpret_cast< wxSize * >(argp1);
4757 arg2 = obj1;
4758 {
4759 result = (bool)wxSize___eq__(arg1,arg2);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 {
4763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4764 }
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 wxSize *arg1 = (wxSize *) 0 ;
4774 PyObject *arg2 = (PyObject *) 0 ;
4775 bool result;
4776 void *argp1 = 0 ;
4777 int res1 = 0 ;
4778 PyObject * obj0 = 0 ;
4779 PyObject * obj1 = 0 ;
4780 char * kwnames[] = {
4781 (char *) "self",(char *) "other", NULL
4782 };
4783
4784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4786 if (!SWIG_IsOK(res1)) {
4787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4788 }
4789 arg1 = reinterpret_cast< wxSize * >(argp1);
4790 arg2 = obj1;
4791 {
4792 result = (bool)wxSize___ne__(arg1,arg2);
4793 if (PyErr_Occurred()) SWIG_fail;
4794 }
4795 {
4796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4797 }
4798 return resultobj;
4799 fail:
4800 return NULL;
4801 }
4802
4803
4804 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4805 PyObject *resultobj = 0;
4806 wxSize *arg1 = (wxSize *) 0 ;
4807 wxSize *arg2 = 0 ;
4808 wxSize result;
4809 void *argp1 = 0 ;
4810 int res1 = 0 ;
4811 wxSize temp2 ;
4812 PyObject * obj0 = 0 ;
4813 PyObject * obj1 = 0 ;
4814 char * kwnames[] = {
4815 (char *) "self",(char *) "sz", NULL
4816 };
4817
4818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4820 if (!SWIG_IsOK(res1)) {
4821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4822 }
4823 arg1 = reinterpret_cast< wxSize * >(argp1);
4824 {
4825 arg2 = &temp2;
4826 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4827 }
4828 {
4829 result = (arg1)->operator +((wxSize const &)*arg2);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj = 0;
4841 wxSize *arg1 = (wxSize *) 0 ;
4842 wxSize *arg2 = 0 ;
4843 wxSize result;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 wxSize temp2 ;
4847 PyObject * obj0 = 0 ;
4848 PyObject * obj1 = 0 ;
4849 char * kwnames[] = {
4850 (char *) "self",(char *) "sz", NULL
4851 };
4852
4853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4855 if (!SWIG_IsOK(res1)) {
4856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4857 }
4858 arg1 = reinterpret_cast< wxSize * >(argp1);
4859 {
4860 arg2 = &temp2;
4861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4862 }
4863 {
4864 result = (arg1)->operator -((wxSize const &)*arg2);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4868 return resultobj;
4869 fail:
4870 return NULL;
4871 }
4872
4873
4874 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj = 0;
4876 wxSize *arg1 = (wxSize *) 0 ;
4877 wxSize *arg2 = 0 ;
4878 void *argp1 = 0 ;
4879 int res1 = 0 ;
4880 wxSize temp2 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "sz", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 {
4894 arg2 = &temp2;
4895 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4896 }
4897 {
4898 (arg1)->IncTo((wxSize const &)*arg2);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 resultobj = SWIG_Py_Void();
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj = 0;
4910 wxSize *arg1 = (wxSize *) 0 ;
4911 wxSize *arg2 = 0 ;
4912 void *argp1 = 0 ;
4913 int res1 = 0 ;
4914 wxSize temp2 ;
4915 PyObject * obj0 = 0 ;
4916 PyObject * obj1 = 0 ;
4917 char * kwnames[] = {
4918 (char *) "self",(char *) "sz", NULL
4919 };
4920
4921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4923 if (!SWIG_IsOK(res1)) {
4924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4925 }
4926 arg1 = reinterpret_cast< wxSize * >(argp1);
4927 {
4928 arg2 = &temp2;
4929 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4930 }
4931 {
4932 (arg1)->DecTo((wxSize const &)*arg2);
4933 if (PyErr_Occurred()) SWIG_fail;
4934 }
4935 resultobj = SWIG_Py_Void();
4936 return resultobj;
4937 fail:
4938 return NULL;
4939 }
4940
4941
4942 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4943 PyObject *resultobj = 0;
4944 wxSize *arg1 = (wxSize *) 0 ;
4945 int arg2 ;
4946 int arg3 ;
4947 void *argp1 = 0 ;
4948 int res1 = 0 ;
4949 int val2 ;
4950 int ecode2 = 0 ;
4951 int val3 ;
4952 int ecode3 = 0 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 PyObject * obj2 = 0 ;
4956 char * kwnames[] = {
4957 (char *) "self",(char *) "dx",(char *) "dy", NULL
4958 };
4959
4960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4962 if (!SWIG_IsOK(res1)) {
4963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4964 }
4965 arg1 = reinterpret_cast< wxSize * >(argp1);
4966 ecode2 = SWIG_AsVal_int(obj1, &val2);
4967 if (!SWIG_IsOK(ecode2)) {
4968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4969 }
4970 arg2 = static_cast< int >(val2);
4971 ecode3 = SWIG_AsVal_int(obj2, &val3);
4972 if (!SWIG_IsOK(ecode3)) {
4973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4974 }
4975 arg3 = static_cast< int >(val3);
4976 {
4977 (arg1)->IncBy(arg2,arg3);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_Py_Void();
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj = 0;
4989 wxSize *arg1 = (wxSize *) 0 ;
4990 int arg2 ;
4991 int arg3 ;
4992 void *argp1 = 0 ;
4993 int res1 = 0 ;
4994 int val2 ;
4995 int ecode2 = 0 ;
4996 int val3 ;
4997 int ecode3 = 0 ;
4998 PyObject * obj0 = 0 ;
4999 PyObject * obj1 = 0 ;
5000 PyObject * obj2 = 0 ;
5001 char * kwnames[] = {
5002 (char *) "self",(char *) "dx",(char *) "dy", NULL
5003 };
5004
5005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5007 if (!SWIG_IsOK(res1)) {
5008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5009 }
5010 arg1 = reinterpret_cast< wxSize * >(argp1);
5011 ecode2 = SWIG_AsVal_int(obj1, &val2);
5012 if (!SWIG_IsOK(ecode2)) {
5013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5014 }
5015 arg2 = static_cast< int >(val2);
5016 ecode3 = SWIG_AsVal_int(obj2, &val3);
5017 if (!SWIG_IsOK(ecode3)) {
5018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5019 }
5020 arg3 = static_cast< int >(val3);
5021 {
5022 (arg1)->DecBy(arg2,arg3);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 resultobj = SWIG_Py_Void();
5026 return resultobj;
5027 fail:
5028 return NULL;
5029 }
5030
5031
5032 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5033 PyObject *resultobj = 0;
5034 wxSize *arg1 = (wxSize *) 0 ;
5035 float arg2 ;
5036 float arg3 ;
5037 void *argp1 = 0 ;
5038 int res1 = 0 ;
5039 float val2 ;
5040 int ecode2 = 0 ;
5041 float val3 ;
5042 int ecode3 = 0 ;
5043 PyObject * obj0 = 0 ;
5044 PyObject * obj1 = 0 ;
5045 PyObject * obj2 = 0 ;
5046 char * kwnames[] = {
5047 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5048 };
5049
5050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5052 if (!SWIG_IsOK(res1)) {
5053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5054 }
5055 arg1 = reinterpret_cast< wxSize * >(argp1);
5056 ecode2 = SWIG_AsVal_float(obj1, &val2);
5057 if (!SWIG_IsOK(ecode2)) {
5058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5059 }
5060 arg2 = static_cast< float >(val2);
5061 ecode3 = SWIG_AsVal_float(obj2, &val3);
5062 if (!SWIG_IsOK(ecode3)) {
5063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5064 }
5065 arg3 = static_cast< float >(val3);
5066 {
5067 (arg1)->Scale(arg2,arg3);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_Py_Void();
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj = 0;
5079 wxSize *arg1 = (wxSize *) 0 ;
5080 int arg2 ;
5081 int arg3 ;
5082 void *argp1 = 0 ;
5083 int res1 = 0 ;
5084 int val2 ;
5085 int ecode2 = 0 ;
5086 int val3 ;
5087 int ecode3 = 0 ;
5088 PyObject * obj0 = 0 ;
5089 PyObject * obj1 = 0 ;
5090 PyObject * obj2 = 0 ;
5091 char * kwnames[] = {
5092 (char *) "self",(char *) "w",(char *) "h", NULL
5093 };
5094
5095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5097 if (!SWIG_IsOK(res1)) {
5098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5099 }
5100 arg1 = reinterpret_cast< wxSize * >(argp1);
5101 ecode2 = SWIG_AsVal_int(obj1, &val2);
5102 if (!SWIG_IsOK(ecode2)) {
5103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5104 }
5105 arg2 = static_cast< int >(val2);
5106 ecode3 = SWIG_AsVal_int(obj2, &val3);
5107 if (!SWIG_IsOK(ecode3)) {
5108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5109 }
5110 arg3 = static_cast< int >(val3);
5111 {
5112 (arg1)->Set(arg2,arg3);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 resultobj = SWIG_Py_Void();
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5123 PyObject *resultobj = 0;
5124 wxSize *arg1 = (wxSize *) 0 ;
5125 int arg2 ;
5126 void *argp1 = 0 ;
5127 int res1 = 0 ;
5128 int val2 ;
5129 int ecode2 = 0 ;
5130 PyObject * obj0 = 0 ;
5131 PyObject * obj1 = 0 ;
5132 char * kwnames[] = {
5133 (char *) "self",(char *) "w", NULL
5134 };
5135
5136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5138 if (!SWIG_IsOK(res1)) {
5139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5140 }
5141 arg1 = reinterpret_cast< wxSize * >(argp1);
5142 ecode2 = SWIG_AsVal_int(obj1, &val2);
5143 if (!SWIG_IsOK(ecode2)) {
5144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5145 }
5146 arg2 = static_cast< int >(val2);
5147 {
5148 (arg1)->SetWidth(arg2);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 resultobj = SWIG_Py_Void();
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj = 0;
5160 wxSize *arg1 = (wxSize *) 0 ;
5161 int arg2 ;
5162 void *argp1 = 0 ;
5163 int res1 = 0 ;
5164 int val2 ;
5165 int ecode2 = 0 ;
5166 PyObject * obj0 = 0 ;
5167 PyObject * obj1 = 0 ;
5168 char * kwnames[] = {
5169 (char *) "self",(char *) "h", NULL
5170 };
5171
5172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 ecode2 = SWIG_AsVal_int(obj1, &val2);
5179 if (!SWIG_IsOK(ecode2)) {
5180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5181 }
5182 arg2 = static_cast< int >(val2);
5183 {
5184 (arg1)->SetHeight(arg2);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_Py_Void();
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5195 PyObject *resultobj = 0;
5196 wxSize *arg1 = (wxSize *) 0 ;
5197 int result;
5198 void *argp1 = 0 ;
5199 int res1 = 0 ;
5200 PyObject *swig_obj[1] ;
5201
5202 if (!args) SWIG_fail;
5203 swig_obj[0] = args;
5204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5205 if (!SWIG_IsOK(res1)) {
5206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5207 }
5208 arg1 = reinterpret_cast< wxSize * >(argp1);
5209 {
5210 result = (int)((wxSize const *)arg1)->GetWidth();
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_From_int(static_cast< int >(result));
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5221 PyObject *resultobj = 0;
5222 wxSize *arg1 = (wxSize *) 0 ;
5223 int result;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 PyObject *swig_obj[1] ;
5227
5228 if (!args) SWIG_fail;
5229 swig_obj[0] = args;
5230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5231 if (!SWIG_IsOK(res1)) {
5232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5233 }
5234 arg1 = reinterpret_cast< wxSize * >(argp1);
5235 {
5236 result = (int)((wxSize const *)arg1)->GetHeight();
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 resultobj = SWIG_From_int(static_cast< int >(result));
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5247 PyObject *resultobj = 0;
5248 wxSize *arg1 = (wxSize *) 0 ;
5249 bool result;
5250 void *argp1 = 0 ;
5251 int res1 = 0 ;
5252 PyObject *swig_obj[1] ;
5253
5254 if (!args) SWIG_fail;
5255 swig_obj[0] = args;
5256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5257 if (!SWIG_IsOK(res1)) {
5258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5259 }
5260 arg1 = reinterpret_cast< wxSize * >(argp1);
5261 {
5262 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 {
5266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5267 }
5268 return resultobj;
5269 fail:
5270 return NULL;
5271 }
5272
5273
5274 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5275 PyObject *resultobj = 0;
5276 wxSize *arg1 = (wxSize *) 0 ;
5277 wxSize *arg2 = 0 ;
5278 void *argp1 = 0 ;
5279 int res1 = 0 ;
5280 wxSize temp2 ;
5281 PyObject * obj0 = 0 ;
5282 PyObject * obj1 = 0 ;
5283 char * kwnames[] = {
5284 (char *) "self",(char *) "size", NULL
5285 };
5286
5287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5289 if (!SWIG_IsOK(res1)) {
5290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5291 }
5292 arg1 = reinterpret_cast< wxSize * >(argp1);
5293 {
5294 arg2 = &temp2;
5295 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5296 }
5297 {
5298 (arg1)->SetDefaults((wxSize const &)*arg2);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_Py_Void();
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5309 PyObject *resultobj = 0;
5310 wxSize *arg1 = (wxSize *) 0 ;
5311 PyObject *result = 0 ;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 PyObject *swig_obj[1] ;
5315
5316 if (!args) SWIG_fail;
5317 swig_obj[0] = args;
5318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5319 if (!SWIG_IsOK(res1)) {
5320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5321 }
5322 arg1 = reinterpret_cast< wxSize * >(argp1);
5323 {
5324 result = (PyObject *)wxSize_Get(arg1);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = result;
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *obj;
5336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5337 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5338 return SWIG_Py_Void();
5339 }
5340
5341 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5342 return SWIG_Python_InitShadowInstance(args);
5343 }
5344
5345 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 PyObject *resultobj = 0;
5347 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5348 double arg2 ;
5349 void *argp1 = 0 ;
5350 int res1 = 0 ;
5351 double val2 ;
5352 int ecode2 = 0 ;
5353 PyObject *swig_obj[2] ;
5354
5355 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5359 }
5360 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5361 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5362 if (!SWIG_IsOK(ecode2)) {
5363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5364 }
5365 arg2 = static_cast< double >(val2);
5366 if (arg1) (arg1)->x = arg2;
5367
5368 resultobj = SWIG_Py_Void();
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5376 PyObject *resultobj = 0;
5377 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5378 double result;
5379 void *argp1 = 0 ;
5380 int res1 = 0 ;
5381 PyObject *swig_obj[1] ;
5382
5383 if (!args) SWIG_fail;
5384 swig_obj[0] = args;
5385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5386 if (!SWIG_IsOK(res1)) {
5387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5388 }
5389 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5390 result = (double) ((arg1)->x);
5391 resultobj = SWIG_From_double(static_cast< double >(result));
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5399 PyObject *resultobj = 0;
5400 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5401 double arg2 ;
5402 void *argp1 = 0 ;
5403 int res1 = 0 ;
5404 double val2 ;
5405 int ecode2 = 0 ;
5406 PyObject *swig_obj[2] ;
5407
5408 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5415 if (!SWIG_IsOK(ecode2)) {
5416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5417 }
5418 arg2 = static_cast< double >(val2);
5419 if (arg1) (arg1)->y = arg2;
5420
5421 resultobj = SWIG_Py_Void();
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 double result;
5432 void *argp1 = 0 ;
5433 int res1 = 0 ;
5434 PyObject *swig_obj[1] ;
5435
5436 if (!args) SWIG_fail;
5437 swig_obj[0] = args;
5438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5439 if (!SWIG_IsOK(res1)) {
5440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5441 }
5442 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5443 result = (double) ((arg1)->y);
5444 resultobj = SWIG_From_double(static_cast< double >(result));
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5452 PyObject *resultobj = 0;
5453 double arg1 = (double) 0.0 ;
5454 double arg2 = (double) 0.0 ;
5455 wxRealPoint *result = 0 ;
5456 double val1 ;
5457 int ecode1 = 0 ;
5458 double val2 ;
5459 int ecode2 = 0 ;
5460 PyObject * obj0 = 0 ;
5461 PyObject * obj1 = 0 ;
5462 char * kwnames[] = {
5463 (char *) "x",(char *) "y", NULL
5464 };
5465
5466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5467 if (obj0) {
5468 ecode1 = SWIG_AsVal_double(obj0, &val1);
5469 if (!SWIG_IsOK(ecode1)) {
5470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5471 }
5472 arg1 = static_cast< double >(val1);
5473 }
5474 if (obj1) {
5475 ecode2 = SWIG_AsVal_double(obj1, &val2);
5476 if (!SWIG_IsOK(ecode2)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5478 }
5479 arg2 = static_cast< double >(val2);
5480 }
5481 {
5482 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5495 void *argp1 = 0 ;
5496 int res1 = 0 ;
5497 PyObject *swig_obj[1] ;
5498
5499 if (!args) SWIG_fail;
5500 swig_obj[0] = args;
5501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5502 if (!SWIG_IsOK(res1)) {
5503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5504 }
5505 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5506 {
5507 delete arg1;
5508
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_Py_Void();
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 PyObject *arg2 = (PyObject *) 0 ;
5522 bool result;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 PyObject * obj0 = 0 ;
5526 PyObject * obj1 = 0 ;
5527 char * kwnames[] = {
5528 (char *) "self",(char *) "other", NULL
5529 };
5530
5531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5533 if (!SWIG_IsOK(res1)) {
5534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5535 }
5536 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5537 arg2 = obj1;
5538 {
5539 result = (bool)wxRealPoint___eq__(arg1,arg2);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 {
5543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5544 }
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5552 PyObject *resultobj = 0;
5553 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5554 PyObject *arg2 = (PyObject *) 0 ;
5555 bool result;
5556 void *argp1 = 0 ;
5557 int res1 = 0 ;
5558 PyObject * obj0 = 0 ;
5559 PyObject * obj1 = 0 ;
5560 char * kwnames[] = {
5561 (char *) "self",(char *) "other", NULL
5562 };
5563
5564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5568 }
5569 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5570 arg2 = obj1;
5571 {
5572 result = (bool)wxRealPoint___ne__(arg1,arg2);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 {
5576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj = 0;
5586 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5587 wxRealPoint *arg2 = 0 ;
5588 wxRealPoint result;
5589 void *argp1 = 0 ;
5590 int res1 = 0 ;
5591 wxRealPoint temp2 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char * kwnames[] = {
5595 (char *) "self",(char *) "pt", NULL
5596 };
5597
5598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5600 if (!SWIG_IsOK(res1)) {
5601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5602 }
5603 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5604 {
5605 arg2 = &temp2;
5606 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5607 }
5608 {
5609 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj = 0;
5621 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5622 wxRealPoint *arg2 = 0 ;
5623 wxRealPoint result;
5624 void *argp1 = 0 ;
5625 int res1 = 0 ;
5626 wxRealPoint temp2 ;
5627 PyObject * obj0 = 0 ;
5628 PyObject * obj1 = 0 ;
5629 char * kwnames[] = {
5630 (char *) "self",(char *) "pt", NULL
5631 };
5632
5633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5635 if (!SWIG_IsOK(res1)) {
5636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5637 }
5638 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5639 {
5640 arg2 = &temp2;
5641 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5642 }
5643 {
5644 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5648 return resultobj;
5649 fail:
5650 return NULL;
5651 }
5652
5653
5654 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5655 PyObject *resultobj = 0;
5656 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5657 double arg2 ;
5658 double arg3 ;
5659 void *argp1 = 0 ;
5660 int res1 = 0 ;
5661 double val2 ;
5662 int ecode2 = 0 ;
5663 double val3 ;
5664 int ecode3 = 0 ;
5665 PyObject * obj0 = 0 ;
5666 PyObject * obj1 = 0 ;
5667 PyObject * obj2 = 0 ;
5668 char * kwnames[] = {
5669 (char *) "self",(char *) "x",(char *) "y", NULL
5670 };
5671
5672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5674 if (!SWIG_IsOK(res1)) {
5675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5676 }
5677 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5678 ecode2 = SWIG_AsVal_double(obj1, &val2);
5679 if (!SWIG_IsOK(ecode2)) {
5680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5681 }
5682 arg2 = static_cast< double >(val2);
5683 ecode3 = SWIG_AsVal_double(obj2, &val3);
5684 if (!SWIG_IsOK(ecode3)) {
5685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5686 }
5687 arg3 = static_cast< double >(val3);
5688 {
5689 wxRealPoint_Set(arg1,arg2,arg3);
5690 if (PyErr_Occurred()) SWIG_fail;
5691 }
5692 resultobj = SWIG_Py_Void();
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5700 PyObject *resultobj = 0;
5701 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5702 PyObject *result = 0 ;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 PyObject *swig_obj[1] ;
5706
5707 if (!args) SWIG_fail;
5708 swig_obj[0] = args;
5709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5710 if (!SWIG_IsOK(res1)) {
5711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5712 }
5713 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5714 {
5715 result = (PyObject *)wxRealPoint_Get(arg1);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 resultobj = result;
5719 return resultobj;
5720 fail:
5721 return NULL;
5722 }
5723
5724
5725 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5726 PyObject *obj;
5727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5728 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5729 return SWIG_Py_Void();
5730 }
5731
5732 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5733 return SWIG_Python_InitShadowInstance(args);
5734 }
5735
5736 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737 PyObject *resultobj = 0;
5738 wxPoint *arg1 = (wxPoint *) 0 ;
5739 int arg2 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 int val2 ;
5743 int ecode2 = 0 ;
5744 PyObject *swig_obj[2] ;
5745
5746 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5748 if (!SWIG_IsOK(res1)) {
5749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5750 }
5751 arg1 = reinterpret_cast< wxPoint * >(argp1);
5752 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5753 if (!SWIG_IsOK(ecode2)) {
5754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5755 }
5756 arg2 = static_cast< int >(val2);
5757 if (arg1) (arg1)->x = arg2;
5758
5759 resultobj = SWIG_Py_Void();
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5767 PyObject *resultobj = 0;
5768 wxPoint *arg1 = (wxPoint *) 0 ;
5769 int result;
5770 void *argp1 = 0 ;
5771 int res1 = 0 ;
5772 PyObject *swig_obj[1] ;
5773
5774 if (!args) SWIG_fail;
5775 swig_obj[0] = args;
5776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5777 if (!SWIG_IsOK(res1)) {
5778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5779 }
5780 arg1 = reinterpret_cast< wxPoint * >(argp1);
5781 result = (int) ((arg1)->x);
5782 resultobj = SWIG_From_int(static_cast< int >(result));
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5790 PyObject *resultobj = 0;
5791 wxPoint *arg1 = (wxPoint *) 0 ;
5792 int arg2 ;
5793 void *argp1 = 0 ;
5794 int res1 = 0 ;
5795 int val2 ;
5796 int ecode2 = 0 ;
5797 PyObject *swig_obj[2] ;
5798
5799 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5801 if (!SWIG_IsOK(res1)) {
5802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5803 }
5804 arg1 = reinterpret_cast< wxPoint * >(argp1);
5805 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5806 if (!SWIG_IsOK(ecode2)) {
5807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5808 }
5809 arg2 = static_cast< int >(val2);
5810 if (arg1) (arg1)->y = arg2;
5811
5812 resultobj = SWIG_Py_Void();
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5820 PyObject *resultobj = 0;
5821 wxPoint *arg1 = (wxPoint *) 0 ;
5822 int result;
5823 void *argp1 = 0 ;
5824 int res1 = 0 ;
5825 PyObject *swig_obj[1] ;
5826
5827 if (!args) SWIG_fail;
5828 swig_obj[0] = args;
5829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5830 if (!SWIG_IsOK(res1)) {
5831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5832 }
5833 arg1 = reinterpret_cast< wxPoint * >(argp1);
5834 result = (int) ((arg1)->y);
5835 resultobj = SWIG_From_int(static_cast< int >(result));
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 int arg1 = (int) 0 ;
5845 int arg2 = (int) 0 ;
5846 wxPoint *result = 0 ;
5847 int val1 ;
5848 int ecode1 = 0 ;
5849 int val2 ;
5850 int ecode2 = 0 ;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 char * kwnames[] = {
5854 (char *) "x",(char *) "y", NULL
5855 };
5856
5857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5858 if (obj0) {
5859 ecode1 = SWIG_AsVal_int(obj0, &val1);
5860 if (!SWIG_IsOK(ecode1)) {
5861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5862 }
5863 arg1 = static_cast< int >(val1);
5864 }
5865 if (obj1) {
5866 ecode2 = SWIG_AsVal_int(obj1, &val2);
5867 if (!SWIG_IsOK(ecode2)) {
5868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5869 }
5870 arg2 = static_cast< int >(val2);
5871 }
5872 {
5873 result = (wxPoint *)new wxPoint(arg1,arg2);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 void *argp1 = 0 ;
5887 int res1 = 0 ;
5888 PyObject *swig_obj[1] ;
5889
5890 if (!args) SWIG_fail;
5891 swig_obj[0] = args;
5892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5893 if (!SWIG_IsOK(res1)) {
5894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5895 }
5896 arg1 = reinterpret_cast< wxPoint * >(argp1);
5897 {
5898 delete arg1;
5899
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 resultobj = SWIG_Py_Void();
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = 0;
5911 wxPoint *arg1 = (wxPoint *) 0 ;
5912 PyObject *arg2 = (PyObject *) 0 ;
5913 bool result;
5914 void *argp1 = 0 ;
5915 int res1 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 char * kwnames[] = {
5919 (char *) "self",(char *) "other", NULL
5920 };
5921
5922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5924 if (!SWIG_IsOK(res1)) {
5925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5926 }
5927 arg1 = reinterpret_cast< wxPoint * >(argp1);
5928 arg2 = obj1;
5929 {
5930 result = (bool)wxPoint___eq__(arg1,arg2);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 {
5934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5935 }
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxPoint *arg1 = (wxPoint *) 0 ;
5945 PyObject *arg2 = (PyObject *) 0 ;
5946 bool result;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char * kwnames[] = {
5952 (char *) "self",(char *) "other", NULL
5953 };
5954
5955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5957 if (!SWIG_IsOK(res1)) {
5958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5959 }
5960 arg1 = reinterpret_cast< wxPoint * >(argp1);
5961 arg2 = obj1;
5962 {
5963 result = (bool)wxPoint___ne__(arg1,arg2);
5964 if (PyErr_Occurred()) SWIG_fail;
5965 }
5966 {
5967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5968 }
5969 return resultobj;
5970 fail:
5971 return NULL;
5972 }
5973
5974
5975 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj = 0;
5977 wxPoint *arg1 = (wxPoint *) 0 ;
5978 wxPoint *arg2 = 0 ;
5979 wxPoint result;
5980 void *argp1 = 0 ;
5981 int res1 = 0 ;
5982 wxPoint temp2 ;
5983 PyObject * obj0 = 0 ;
5984 PyObject * obj1 = 0 ;
5985 char * kwnames[] = {
5986 (char *) "self",(char *) "pt", NULL
5987 };
5988
5989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5991 if (!SWIG_IsOK(res1)) {
5992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5993 }
5994 arg1 = reinterpret_cast< wxPoint * >(argp1);
5995 {
5996 arg2 = &temp2;
5997 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5998 }
5999 {
6000 result = (arg1)->operator +((wxPoint const &)*arg2);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 wxPoint *arg1 = (wxPoint *) 0 ;
6013 wxPoint *arg2 = 0 ;
6014 wxPoint result;
6015 void *argp1 = 0 ;
6016 int res1 = 0 ;
6017 wxPoint temp2 ;
6018 PyObject * obj0 = 0 ;
6019 PyObject * obj1 = 0 ;
6020 char * kwnames[] = {
6021 (char *) "self",(char *) "pt", NULL
6022 };
6023
6024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6026 if (!SWIG_IsOK(res1)) {
6027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6028 }
6029 arg1 = reinterpret_cast< wxPoint * >(argp1);
6030 {
6031 arg2 = &temp2;
6032 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6033 }
6034 {
6035 result = (arg1)->operator -((wxPoint const &)*arg2);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj = 0;
6047 wxPoint *arg1 = (wxPoint *) 0 ;
6048 wxPoint *arg2 = 0 ;
6049 wxPoint *result = 0 ;
6050 void *argp1 = 0 ;
6051 int res1 = 0 ;
6052 wxPoint temp2 ;
6053 PyObject * obj0 = 0 ;
6054 PyObject * obj1 = 0 ;
6055 char * kwnames[] = {
6056 (char *) "self",(char *) "pt", NULL
6057 };
6058
6059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6061 if (!SWIG_IsOK(res1)) {
6062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6063 }
6064 arg1 = reinterpret_cast< wxPoint * >(argp1);
6065 {
6066 arg2 = &temp2;
6067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6068 }
6069 {
6070 {
6071 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6072 result = (wxPoint *) &_result_ref;
6073 }
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj = 0;
6085 wxPoint *arg1 = (wxPoint *) 0 ;
6086 wxPoint *arg2 = 0 ;
6087 wxPoint *result = 0 ;
6088 void *argp1 = 0 ;
6089 int res1 = 0 ;
6090 wxPoint temp2 ;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "self",(char *) "pt", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6099 if (!SWIG_IsOK(res1)) {
6100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6101 }
6102 arg1 = reinterpret_cast< wxPoint * >(argp1);
6103 {
6104 arg2 = &temp2;
6105 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6106 }
6107 {
6108 {
6109 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6110 result = (wxPoint *) &_result_ref;
6111 }
6112 if (PyErr_Occurred()) SWIG_fail;
6113 }
6114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6115 return resultobj;
6116 fail:
6117 return NULL;
6118 }
6119
6120
6121 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6122 PyObject *resultobj = 0;
6123 wxPoint *arg1 = (wxPoint *) 0 ;
6124 long arg2 ;
6125 long arg3 ;
6126 void *argp1 = 0 ;
6127 int res1 = 0 ;
6128 long val2 ;
6129 int ecode2 = 0 ;
6130 long val3 ;
6131 int ecode3 = 0 ;
6132 PyObject * obj0 = 0 ;
6133 PyObject * obj1 = 0 ;
6134 PyObject * obj2 = 0 ;
6135 char * kwnames[] = {
6136 (char *) "self",(char *) "x",(char *) "y", NULL
6137 };
6138
6139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6141 if (!SWIG_IsOK(res1)) {
6142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6143 }
6144 arg1 = reinterpret_cast< wxPoint * >(argp1);
6145 ecode2 = SWIG_AsVal_long(obj1, &val2);
6146 if (!SWIG_IsOK(ecode2)) {
6147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6148 }
6149 arg2 = static_cast< long >(val2);
6150 ecode3 = SWIG_AsVal_long(obj2, &val3);
6151 if (!SWIG_IsOK(ecode3)) {
6152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6153 }
6154 arg3 = static_cast< long >(val3);
6155 {
6156 wxPoint_Set(arg1,arg2,arg3);
6157 if (PyErr_Occurred()) SWIG_fail;
6158 }
6159 resultobj = SWIG_Py_Void();
6160 return resultobj;
6161 fail:
6162 return NULL;
6163 }
6164
6165
6166 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6167 PyObject *resultobj = 0;
6168 wxPoint *arg1 = (wxPoint *) 0 ;
6169 PyObject *result = 0 ;
6170 void *argp1 = 0 ;
6171 int res1 = 0 ;
6172 PyObject *swig_obj[1] ;
6173
6174 if (!args) SWIG_fail;
6175 swig_obj[0] = args;
6176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6177 if (!SWIG_IsOK(res1)) {
6178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6179 }
6180 arg1 = reinterpret_cast< wxPoint * >(argp1);
6181 {
6182 result = (PyObject *)wxPoint_Get(arg1);
6183 if (PyErr_Occurred()) SWIG_fail;
6184 }
6185 resultobj = result;
6186 return resultobj;
6187 fail:
6188 return NULL;
6189 }
6190
6191
6192 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6193 PyObject *obj;
6194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6195 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6196 return SWIG_Py_Void();
6197 }
6198
6199 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6200 return SWIG_Python_InitShadowInstance(args);
6201 }
6202
6203 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 int arg1 = (int) 0 ;
6206 int arg2 = (int) 0 ;
6207 int arg3 = (int) 0 ;
6208 int arg4 = (int) 0 ;
6209 wxRect *result = 0 ;
6210 int val1 ;
6211 int ecode1 = 0 ;
6212 int val2 ;
6213 int ecode2 = 0 ;
6214 int val3 ;
6215 int ecode3 = 0 ;
6216 int val4 ;
6217 int ecode4 = 0 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 PyObject * obj2 = 0 ;
6221 PyObject * obj3 = 0 ;
6222 char * kwnames[] = {
6223 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6224 };
6225
6226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6227 if (obj0) {
6228 ecode1 = SWIG_AsVal_int(obj0, &val1);
6229 if (!SWIG_IsOK(ecode1)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6231 }
6232 arg1 = static_cast< int >(val1);
6233 }
6234 if (obj1) {
6235 ecode2 = SWIG_AsVal_int(obj1, &val2);
6236 if (!SWIG_IsOK(ecode2)) {
6237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6238 }
6239 arg2 = static_cast< int >(val2);
6240 }
6241 if (obj2) {
6242 ecode3 = SWIG_AsVal_int(obj2, &val3);
6243 if (!SWIG_IsOK(ecode3)) {
6244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6245 }
6246 arg3 = static_cast< int >(val3);
6247 }
6248 if (obj3) {
6249 ecode4 = SWIG_AsVal_int(obj3, &val4);
6250 if (!SWIG_IsOK(ecode4)) {
6251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6252 }
6253 arg4 = static_cast< int >(val4);
6254 }
6255 {
6256 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj = 0;
6268 wxPoint *arg1 = 0 ;
6269 wxPoint *arg2 = 0 ;
6270 wxRect *result = 0 ;
6271 wxPoint temp1 ;
6272 wxPoint temp2 ;
6273 PyObject * obj0 = 0 ;
6274 PyObject * obj1 = 0 ;
6275 char * kwnames[] = {
6276 (char *) "topLeft",(char *) "bottomRight", NULL
6277 };
6278
6279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6280 {
6281 arg1 = &temp1;
6282 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6283 }
6284 {
6285 arg2 = &temp2;
6286 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6287 }
6288 {
6289 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6290 if (PyErr_Occurred()) SWIG_fail;
6291 }
6292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj = 0;
6301 wxPoint *arg1 = 0 ;
6302 wxSize *arg2 = 0 ;
6303 wxRect *result = 0 ;
6304 wxPoint temp1 ;
6305 wxSize temp2 ;
6306 PyObject * obj0 = 0 ;
6307 PyObject * obj1 = 0 ;
6308 char * kwnames[] = {
6309 (char *) "pos",(char *) "size", NULL
6310 };
6311
6312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6313 {
6314 arg1 = &temp1;
6315 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6316 }
6317 {
6318 arg2 = &temp2;
6319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6320 }
6321 {
6322 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj = 0;
6334 wxSize *arg1 = 0 ;
6335 wxRect *result = 0 ;
6336 wxSize temp1 ;
6337 PyObject * obj0 = 0 ;
6338 char * kwnames[] = {
6339 (char *) "size", NULL
6340 };
6341
6342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6343 {
6344 arg1 = &temp1;
6345 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6346 }
6347 {
6348 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6359 PyObject *resultobj = 0;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 PyObject *swig_obj[1] ;
6364
6365 if (!args) SWIG_fail;
6366 swig_obj[0] = args;
6367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6368 if (!SWIG_IsOK(res1)) {
6369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6370 }
6371 arg1 = reinterpret_cast< wxRect * >(argp1);
6372 {
6373 delete arg1;
6374
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_Py_Void();
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6385 PyObject *resultobj = 0;
6386 wxRect *arg1 = (wxRect *) 0 ;
6387 int result;
6388 void *argp1 = 0 ;
6389 int res1 = 0 ;
6390 PyObject *swig_obj[1] ;
6391
6392 if (!args) SWIG_fail;
6393 swig_obj[0] = args;
6394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6395 if (!SWIG_IsOK(res1)) {
6396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6397 }
6398 arg1 = reinterpret_cast< wxRect * >(argp1);
6399 {
6400 result = (int)((wxRect const *)arg1)->GetX();
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_From_int(static_cast< int >(result));
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int arg2 ;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 int val2 ;
6417 int ecode2 = 0 ;
6418 PyObject * obj0 = 0 ;
6419 PyObject * obj1 = 0 ;
6420 char * kwnames[] = {
6421 (char *) "self",(char *) "x", NULL
6422 };
6423
6424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6426 if (!SWIG_IsOK(res1)) {
6427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6428 }
6429 arg1 = reinterpret_cast< wxRect * >(argp1);
6430 ecode2 = SWIG_AsVal_int(obj1, &val2);
6431 if (!SWIG_IsOK(ecode2)) {
6432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6433 }
6434 arg2 = static_cast< int >(val2);
6435 {
6436 (arg1)->SetX(arg2);
6437 if (PyErr_Occurred()) SWIG_fail;
6438 }
6439 resultobj = SWIG_Py_Void();
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6447 PyObject *resultobj = 0;
6448 wxRect *arg1 = (wxRect *) 0 ;
6449 int result;
6450 void *argp1 = 0 ;
6451 int res1 = 0 ;
6452 PyObject *swig_obj[1] ;
6453
6454 if (!args) SWIG_fail;
6455 swig_obj[0] = args;
6456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6457 if (!SWIG_IsOK(res1)) {
6458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6459 }
6460 arg1 = reinterpret_cast< wxRect * >(argp1);
6461 {
6462 result = (int)(arg1)->GetY();
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 resultobj = SWIG_From_int(static_cast< int >(result));
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj = 0;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 int arg2 ;
6476 void *argp1 = 0 ;
6477 int res1 = 0 ;
6478 int val2 ;
6479 int ecode2 = 0 ;
6480 PyObject * obj0 = 0 ;
6481 PyObject * obj1 = 0 ;
6482 char * kwnames[] = {
6483 (char *) "self",(char *) "y", NULL
6484 };
6485
6486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6488 if (!SWIG_IsOK(res1)) {
6489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6490 }
6491 arg1 = reinterpret_cast< wxRect * >(argp1);
6492 ecode2 = SWIG_AsVal_int(obj1, &val2);
6493 if (!SWIG_IsOK(ecode2)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6495 }
6496 arg2 = static_cast< int >(val2);
6497 {
6498 (arg1)->SetY(arg2);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_Py_Void();
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6509 PyObject *resultobj = 0;
6510 wxRect *arg1 = (wxRect *) 0 ;
6511 int result;
6512 void *argp1 = 0 ;
6513 int res1 = 0 ;
6514 PyObject *swig_obj[1] ;
6515
6516 if (!args) SWIG_fail;
6517 swig_obj[0] = args;
6518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 {
6524 result = (int)((wxRect const *)arg1)->GetWidth();
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 int arg2 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 int val2 ;
6541 int ecode2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "w", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 ecode2 = SWIG_AsVal_int(obj1, &val2);
6555 if (!SWIG_IsOK(ecode2)) {
6556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 (arg1)->SetWidth(arg2);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 int result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 result = (int)((wxRect const *)arg1)->GetHeight();
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 resultobj = SWIG_From_int(static_cast< int >(result));
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6597 PyObject *resultobj = 0;
6598 wxRect *arg1 = (wxRect *) 0 ;
6599 int arg2 ;
6600 void *argp1 = 0 ;
6601 int res1 = 0 ;
6602 int val2 ;
6603 int ecode2 = 0 ;
6604 PyObject * obj0 = 0 ;
6605 PyObject * obj1 = 0 ;
6606 char * kwnames[] = {
6607 (char *) "self",(char *) "h", NULL
6608 };
6609
6610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6612 if (!SWIG_IsOK(res1)) {
6613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6614 }
6615 arg1 = reinterpret_cast< wxRect * >(argp1);
6616 ecode2 = SWIG_AsVal_int(obj1, &val2);
6617 if (!SWIG_IsOK(ecode2)) {
6618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6619 }
6620 arg2 = static_cast< int >(val2);
6621 {
6622 (arg1)->SetHeight(arg2);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_Py_Void();
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxPoint result;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 PyObject *swig_obj[1] ;
6639
6640 if (!args) SWIG_fail;
6641 swig_obj[0] = args;
6642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6643 if (!SWIG_IsOK(res1)) {
6644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 result = ((wxRect const *)arg1)->GetPosition();
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj = 0;
6660 wxRect *arg1 = (wxRect *) 0 ;
6661 wxPoint *arg2 = 0 ;
6662 void *argp1 = 0 ;
6663 int res1 = 0 ;
6664 wxPoint temp2 ;
6665 PyObject * obj0 = 0 ;
6666 PyObject * obj1 = 0 ;
6667 char * kwnames[] = {
6668 (char *) "self",(char *) "p", NULL
6669 };
6670
6671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6673 if (!SWIG_IsOK(res1)) {
6674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6675 }
6676 arg1 = reinterpret_cast< wxRect * >(argp1);
6677 {
6678 arg2 = &temp2;
6679 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6680 }
6681 {
6682 (arg1)->SetPosition((wxPoint const &)*arg2);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_Py_Void();
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6693 PyObject *resultobj = 0;
6694 wxRect *arg1 = (wxRect *) 0 ;
6695 wxSize result;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 PyObject *swig_obj[1] ;
6699
6700 if (!args) SWIG_fail;
6701 swig_obj[0] = args;
6702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6703 if (!SWIG_IsOK(res1)) {
6704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6705 }
6706 arg1 = reinterpret_cast< wxRect * >(argp1);
6707 {
6708 result = ((wxRect const *)arg1)->GetSize();
6709 if (PyErr_Occurred()) SWIG_fail;
6710 }
6711 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6712 return resultobj;
6713 fail:
6714 return NULL;
6715 }
6716
6717
6718 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6719 PyObject *resultobj = 0;
6720 wxRect *arg1 = (wxRect *) 0 ;
6721 wxSize *arg2 = 0 ;
6722 void *argp1 = 0 ;
6723 int res1 = 0 ;
6724 wxSize temp2 ;
6725 PyObject * obj0 = 0 ;
6726 PyObject * obj1 = 0 ;
6727 char * kwnames[] = {
6728 (char *) "self",(char *) "s", NULL
6729 };
6730
6731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6733 if (!SWIG_IsOK(res1)) {
6734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6735 }
6736 arg1 = reinterpret_cast< wxRect * >(argp1);
6737 {
6738 arg2 = &temp2;
6739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6740 }
6741 {
6742 (arg1)->SetSize((wxSize const &)*arg2);
6743 if (PyErr_Occurred()) SWIG_fail;
6744 }
6745 resultobj = SWIG_Py_Void();
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6753 PyObject *resultobj = 0;
6754 wxRect *arg1 = (wxRect *) 0 ;
6755 bool result;
6756 void *argp1 = 0 ;
6757 int res1 = 0 ;
6758 PyObject *swig_obj[1] ;
6759
6760 if (!args) SWIG_fail;
6761 swig_obj[0] = args;
6762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6763 if (!SWIG_IsOK(res1)) {
6764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6765 }
6766 arg1 = reinterpret_cast< wxRect * >(argp1);
6767 {
6768 result = (bool)((wxRect const *)arg1)->IsEmpty();
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 {
6772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6773 }
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxPoint result;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 PyObject *swig_obj[1] ;
6787
6788 if (!args) SWIG_fail;
6789 swig_obj[0] = args;
6790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 result = ((wxRect const *)arg1)->GetTopLeft();
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = 0;
6808 wxRect *arg1 = (wxRect *) 0 ;
6809 wxPoint *arg2 = 0 ;
6810 void *argp1 = 0 ;
6811 int res1 = 0 ;
6812 wxPoint temp2 ;
6813 PyObject * obj0 = 0 ;
6814 PyObject * obj1 = 0 ;
6815 char * kwnames[] = {
6816 (char *) "self",(char *) "p", NULL
6817 };
6818
6819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6821 if (!SWIG_IsOK(res1)) {
6822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6823 }
6824 arg1 = reinterpret_cast< wxRect * >(argp1);
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_Py_Void();
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 wxPoint result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 result = ((wxRect const *)arg1)->GetBottomRight();
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6867 PyObject *resultobj = 0;
6868 wxRect *arg1 = (wxRect *) 0 ;
6869 wxPoint *arg2 = 0 ;
6870 void *argp1 = 0 ;
6871 int res1 = 0 ;
6872 wxPoint temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char * kwnames[] = {
6876 (char *) "self",(char *) "p", NULL
6877 };
6878
6879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6881 if (!SWIG_IsOK(res1)) {
6882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6883 }
6884 arg1 = reinterpret_cast< wxRect * >(argp1);
6885 {
6886 arg2 = &temp2;
6887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6888 }
6889 {
6890 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6901 PyObject *resultobj = 0;
6902 wxRect *arg1 = (wxRect *) 0 ;
6903 wxPoint result;
6904 void *argp1 = 0 ;
6905 int res1 = 0 ;
6906 PyObject *swig_obj[1] ;
6907
6908 if (!args) SWIG_fail;
6909 swig_obj[0] = args;
6910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6911 if (!SWIG_IsOK(res1)) {
6912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6913 }
6914 arg1 = reinterpret_cast< wxRect * >(argp1);
6915 {
6916 result = ((wxRect const *)arg1)->GetTopRight();
6917 if (PyErr_Occurred()) SWIG_fail;
6918 }
6919 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6920 return resultobj;
6921 fail:
6922 return NULL;
6923 }
6924
6925
6926 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6927 PyObject *resultobj = 0;
6928 wxRect *arg1 = (wxRect *) 0 ;
6929 wxPoint *arg2 = 0 ;
6930 void *argp1 = 0 ;
6931 int res1 = 0 ;
6932 wxPoint temp2 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "self",(char *) "p", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6943 }
6944 arg1 = reinterpret_cast< wxRect * >(argp1);
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 (arg1)->SetTopRight((wxPoint const &)*arg2);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 resultobj = SWIG_Py_Void();
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6961 PyObject *resultobj = 0;
6962 wxRect *arg1 = (wxRect *) 0 ;
6963 wxPoint result;
6964 void *argp1 = 0 ;
6965 int res1 = 0 ;
6966 PyObject *swig_obj[1] ;
6967
6968 if (!args) SWIG_fail;
6969 swig_obj[0] = args;
6970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6971 if (!SWIG_IsOK(res1)) {
6972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6973 }
6974 arg1 = reinterpret_cast< wxRect * >(argp1);
6975 {
6976 result = ((wxRect const *)arg1)->GetBottomLeft();
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6987 PyObject *resultobj = 0;
6988 wxRect *arg1 = (wxRect *) 0 ;
6989 wxPoint *arg2 = 0 ;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 wxPoint temp2 ;
6993 PyObject * obj0 = 0 ;
6994 PyObject * obj1 = 0 ;
6995 char * kwnames[] = {
6996 (char *) "self",(char *) "p", NULL
6997 };
6998
6999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7001 if (!SWIG_IsOK(res1)) {
7002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7003 }
7004 arg1 = reinterpret_cast< wxRect * >(argp1);
7005 {
7006 arg2 = &temp2;
7007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7008 }
7009 {
7010 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_Py_Void();
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7021 PyObject *resultobj = 0;
7022 wxRect *arg1 = (wxRect *) 0 ;
7023 int result;
7024 void *argp1 = 0 ;
7025 int res1 = 0 ;
7026 PyObject *swig_obj[1] ;
7027
7028 if (!args) SWIG_fail;
7029 swig_obj[0] = args;
7030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 {
7036 result = (int)((wxRect const *)arg1)->GetLeft();
7037 if (PyErr_Occurred()) SWIG_fail;
7038 }
7039 resultobj = SWIG_From_int(static_cast< int >(result));
7040 return resultobj;
7041 fail:
7042 return NULL;
7043 }
7044
7045
7046 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7047 PyObject *resultobj = 0;
7048 wxRect *arg1 = (wxRect *) 0 ;
7049 int result;
7050 void *argp1 = 0 ;
7051 int res1 = 0 ;
7052 PyObject *swig_obj[1] ;
7053
7054 if (!args) SWIG_fail;
7055 swig_obj[0] = args;
7056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7057 if (!SWIG_IsOK(res1)) {
7058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7059 }
7060 arg1 = reinterpret_cast< wxRect * >(argp1);
7061 {
7062 result = (int)((wxRect const *)arg1)->GetTop();
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_From_int(static_cast< int >(result));
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int result;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 PyObject *swig_obj[1] ;
7079
7080 if (!args) SWIG_fail;
7081 swig_obj[0] = args;
7082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7083 if (!SWIG_IsOK(res1)) {
7084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7085 }
7086 arg1 = reinterpret_cast< wxRect * >(argp1);
7087 {
7088 result = (int)((wxRect const *)arg1)->GetBottom();
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_From_int(static_cast< int >(result));
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7099 PyObject *resultobj = 0;
7100 wxRect *arg1 = (wxRect *) 0 ;
7101 int result;
7102 void *argp1 = 0 ;
7103 int res1 = 0 ;
7104 PyObject *swig_obj[1] ;
7105
7106 if (!args) SWIG_fail;
7107 swig_obj[0] = args;
7108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7109 if (!SWIG_IsOK(res1)) {
7110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7111 }
7112 arg1 = reinterpret_cast< wxRect * >(argp1);
7113 {
7114 result = (int)((wxRect const *)arg1)->GetRight();
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_From_int(static_cast< int >(result));
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = 0;
7126 wxRect *arg1 = (wxRect *) 0 ;
7127 int arg2 ;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 int val2 ;
7131 int ecode2 = 0 ;
7132 PyObject * obj0 = 0 ;
7133 PyObject * obj1 = 0 ;
7134 char * kwnames[] = {
7135 (char *) "self",(char *) "left", NULL
7136 };
7137
7138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7140 if (!SWIG_IsOK(res1)) {
7141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7142 }
7143 arg1 = reinterpret_cast< wxRect * >(argp1);
7144 ecode2 = SWIG_AsVal_int(obj1, &val2);
7145 if (!SWIG_IsOK(ecode2)) {
7146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7147 }
7148 arg2 = static_cast< int >(val2);
7149 {
7150 (arg1)->SetLeft(arg2);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_Py_Void();
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7161 PyObject *resultobj = 0;
7162 wxRect *arg1 = (wxRect *) 0 ;
7163 int arg2 ;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 int val2 ;
7167 int ecode2 = 0 ;
7168 PyObject * obj0 = 0 ;
7169 PyObject * obj1 = 0 ;
7170 char * kwnames[] = {
7171 (char *) "self",(char *) "right", NULL
7172 };
7173
7174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7176 if (!SWIG_IsOK(res1)) {
7177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7178 }
7179 arg1 = reinterpret_cast< wxRect * >(argp1);
7180 ecode2 = SWIG_AsVal_int(obj1, &val2);
7181 if (!SWIG_IsOK(ecode2)) {
7182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7183 }
7184 arg2 = static_cast< int >(val2);
7185 {
7186 (arg1)->SetRight(arg2);
7187 if (PyErr_Occurred()) SWIG_fail;
7188 }
7189 resultobj = SWIG_Py_Void();
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxRect *arg1 = (wxRect *) 0 ;
7199 int arg2 ;
7200 void *argp1 = 0 ;
7201 int res1 = 0 ;
7202 int val2 ;
7203 int ecode2 = 0 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 char * kwnames[] = {
7207 (char *) "self",(char *) "top", NULL
7208 };
7209
7210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7212 if (!SWIG_IsOK(res1)) {
7213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7214 }
7215 arg1 = reinterpret_cast< wxRect * >(argp1);
7216 ecode2 = SWIG_AsVal_int(obj1, &val2);
7217 if (!SWIG_IsOK(ecode2)) {
7218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7219 }
7220 arg2 = static_cast< int >(val2);
7221 {
7222 (arg1)->SetTop(arg2);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 resultobj = SWIG_Py_Void();
7226 return resultobj;
7227 fail:
7228 return NULL;
7229 }
7230
7231
7232 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7233 PyObject *resultobj = 0;
7234 wxRect *arg1 = (wxRect *) 0 ;
7235 int arg2 ;
7236 void *argp1 = 0 ;
7237 int res1 = 0 ;
7238 int val2 ;
7239 int ecode2 = 0 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "self",(char *) "bottom", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7250 }
7251 arg1 = reinterpret_cast< wxRect * >(argp1);
7252 ecode2 = SWIG_AsVal_int(obj1, &val2);
7253 if (!SWIG_IsOK(ecode2)) {
7254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7255 }
7256 arg2 = static_cast< int >(val2);
7257 {
7258 (arg1)->SetBottom(arg2);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_Py_Void();
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxRect *arg1 = (wxRect *) 0 ;
7271 int arg2 ;
7272 int arg3 ;
7273 wxRect *result = 0 ;
7274 void *argp1 = 0 ;
7275 int res1 = 0 ;
7276 int val2 ;
7277 int ecode2 = 0 ;
7278 int val3 ;
7279 int ecode3 = 0 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 PyObject * obj2 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "dx",(char *) "dy", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7291 }
7292 arg1 = reinterpret_cast< wxRect * >(argp1);
7293 ecode2 = SWIG_AsVal_int(obj1, &val2);
7294 if (!SWIG_IsOK(ecode2)) {
7295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7296 }
7297 arg2 = static_cast< int >(val2);
7298 ecode3 = SWIG_AsVal_int(obj2, &val3);
7299 if (!SWIG_IsOK(ecode3)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7301 }
7302 arg3 = static_cast< int >(val3);
7303 {
7304 {
7305 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7306 result = (wxRect *) &_result_ref;
7307 }
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj = 0;
7319 wxRect *arg1 = (wxRect *) 0 ;
7320 int arg2 ;
7321 int arg3 ;
7322 wxRect *result = 0 ;
7323 void *argp1 = 0 ;
7324 int res1 = 0 ;
7325 int val2 ;
7326 int ecode2 = 0 ;
7327 int val3 ;
7328 int ecode3 = 0 ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 PyObject * obj2 = 0 ;
7332 char * kwnames[] = {
7333 (char *) "self",(char *) "dx",(char *) "dy", NULL
7334 };
7335
7336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7338 if (!SWIG_IsOK(res1)) {
7339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7340 }
7341 arg1 = reinterpret_cast< wxRect * >(argp1);
7342 ecode2 = SWIG_AsVal_int(obj1, &val2);
7343 if (!SWIG_IsOK(ecode2)) {
7344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7345 }
7346 arg2 = static_cast< int >(val2);
7347 ecode3 = SWIG_AsVal_int(obj2, &val3);
7348 if (!SWIG_IsOK(ecode3)) {
7349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7350 }
7351 arg3 = static_cast< int >(val3);
7352 {
7353 {
7354 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7355 result = (wxRect *) &_result_ref;
7356 }
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj = 0;
7368 wxRect *arg1 = (wxRect *) 0 ;
7369 int arg2 ;
7370 int arg3 ;
7371 void *argp1 = 0 ;
7372 int res1 = 0 ;
7373 int val2 ;
7374 int ecode2 = 0 ;
7375 int val3 ;
7376 int ecode3 = 0 ;
7377 PyObject * obj0 = 0 ;
7378 PyObject * obj1 = 0 ;
7379 PyObject * obj2 = 0 ;
7380 char * kwnames[] = {
7381 (char *) "self",(char *) "dx",(char *) "dy", NULL
7382 };
7383
7384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7386 if (!SWIG_IsOK(res1)) {
7387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7388 }
7389 arg1 = reinterpret_cast< wxRect * >(argp1);
7390 ecode2 = SWIG_AsVal_int(obj1, &val2);
7391 if (!SWIG_IsOK(ecode2)) {
7392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7393 }
7394 arg2 = static_cast< int >(val2);
7395 ecode3 = SWIG_AsVal_int(obj2, &val3);
7396 if (!SWIG_IsOK(ecode3)) {
7397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7398 }
7399 arg3 = static_cast< int >(val3);
7400 {
7401 (arg1)->Offset(arg2,arg3);
7402 if (PyErr_Occurred()) SWIG_fail;
7403 }
7404 resultobj = SWIG_Py_Void();
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj = 0;
7413 wxRect *arg1 = (wxRect *) 0 ;
7414 wxPoint *arg2 = 0 ;
7415 void *argp1 = 0 ;
7416 int res1 = 0 ;
7417 wxPoint temp2 ;
7418 PyObject * obj0 = 0 ;
7419 PyObject * obj1 = 0 ;
7420 char * kwnames[] = {
7421 (char *) "self",(char *) "pt", NULL
7422 };
7423
7424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7426 if (!SWIG_IsOK(res1)) {
7427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7428 }
7429 arg1 = reinterpret_cast< wxRect * >(argp1);
7430 {
7431 arg2 = &temp2;
7432 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7433 }
7434 {
7435 (arg1)->Offset((wxPoint const &)*arg2);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 resultobj = SWIG_Py_Void();
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = 0;
7447 wxRect *arg1 = (wxRect *) 0 ;
7448 wxRect *arg2 = 0 ;
7449 wxRect result;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 wxRect temp2 ;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 char * kwnames[] = {
7456 (char *) "self",(char *) "rect", NULL
7457 };
7458
7459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7461 if (!SWIG_IsOK(res1)) {
7462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7463 }
7464 arg1 = reinterpret_cast< wxRect * >(argp1);
7465 {
7466 arg2 = &temp2;
7467 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7468 }
7469 {
7470 result = (arg1)->Intersect((wxRect const &)*arg2);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7474 return resultobj;
7475 fail:
7476 return NULL;
7477 }
7478
7479
7480 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7481 PyObject *resultobj = 0;
7482 wxRect *arg1 = (wxRect *) 0 ;
7483 wxRect *arg2 = 0 ;
7484 wxRect result;
7485 void *argp1 = 0 ;
7486 int res1 = 0 ;
7487 wxRect temp2 ;
7488 PyObject * obj0 = 0 ;
7489 PyObject * obj1 = 0 ;
7490 char * kwnames[] = {
7491 (char *) "self",(char *) "rect", NULL
7492 };
7493
7494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7496 if (!SWIG_IsOK(res1)) {
7497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7498 }
7499 arg1 = reinterpret_cast< wxRect * >(argp1);
7500 {
7501 arg2 = &temp2;
7502 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7503 }
7504 {
7505 result = (arg1)->Union((wxRect const &)*arg2);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj = 0;
7517 wxRect *arg1 = (wxRect *) 0 ;
7518 wxRect *arg2 = 0 ;
7519 wxRect result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 wxRect temp2 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char * kwnames[] = {
7526 (char *) "self",(char *) "rect", NULL
7527 };
7528
7529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7533 }
7534 arg1 = reinterpret_cast< wxRect * >(argp1);
7535 {
7536 arg2 = &temp2;
7537 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7538 }
7539 {
7540 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj = 0;
7552 wxRect *arg1 = (wxRect *) 0 ;
7553 wxRect *arg2 = 0 ;
7554 wxRect *result = 0 ;
7555 void *argp1 = 0 ;
7556 int res1 = 0 ;
7557 wxRect temp2 ;
7558 PyObject * obj0 = 0 ;
7559 PyObject * obj1 = 0 ;
7560 char * kwnames[] = {
7561 (char *) "self",(char *) "rect", NULL
7562 };
7563
7564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7566 if (!SWIG_IsOK(res1)) {
7567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7568 }
7569 arg1 = reinterpret_cast< wxRect * >(argp1);
7570 {
7571 arg2 = &temp2;
7572 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7573 }
7574 {
7575 {
7576 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7577 result = (wxRect *) &_result_ref;
7578 }
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj = 0;
7590 wxRect *arg1 = (wxRect *) 0 ;
7591 PyObject *arg2 = (PyObject *) 0 ;
7592 bool result;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 PyObject * obj0 = 0 ;
7596 PyObject * obj1 = 0 ;
7597 char * kwnames[] = {
7598 (char *) "self",(char *) "other", NULL
7599 };
7600
7601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7605 }
7606 arg1 = reinterpret_cast< wxRect * >(argp1);
7607 arg2 = obj1;
7608 {
7609 result = (bool)wxRect___eq__(arg1,arg2);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 PyObject *arg2 = (PyObject *) 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject * obj0 = 0 ;
7629 PyObject * obj1 = 0 ;
7630 char * kwnames[] = {
7631 (char *) "self",(char *) "other", NULL
7632 };
7633
7634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7636 if (!SWIG_IsOK(res1)) {
7637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7638 }
7639 arg1 = reinterpret_cast< wxRect * >(argp1);
7640 arg2 = obj1;
7641 {
7642 result = (bool)wxRect___ne__(arg1,arg2);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 {
7646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7647 }
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj = 0;
7656 wxRect *arg1 = (wxRect *) 0 ;
7657 int arg2 ;
7658 int arg3 ;
7659 bool result;
7660 void *argp1 = 0 ;
7661 int res1 = 0 ;
7662 int val2 ;
7663 int ecode2 = 0 ;
7664 int val3 ;
7665 int ecode3 = 0 ;
7666 PyObject * obj0 = 0 ;
7667 PyObject * obj1 = 0 ;
7668 PyObject * obj2 = 0 ;
7669 char * kwnames[] = {
7670 (char *) "self",(char *) "x",(char *) "y", NULL
7671 };
7672
7673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7675 if (!SWIG_IsOK(res1)) {
7676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7677 }
7678 arg1 = reinterpret_cast< wxRect * >(argp1);
7679 ecode2 = SWIG_AsVal_int(obj1, &val2);
7680 if (!SWIG_IsOK(ecode2)) {
7681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7682 }
7683 arg2 = static_cast< int >(val2);
7684 ecode3 = SWIG_AsVal_int(obj2, &val3);
7685 if (!SWIG_IsOK(ecode3)) {
7686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7687 }
7688 arg3 = static_cast< int >(val3);
7689 {
7690 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 wxPoint *arg2 = 0 ;
7706 bool result;
7707 void *argp1 = 0 ;
7708 int res1 = 0 ;
7709 wxPoint temp2 ;
7710 PyObject * obj0 = 0 ;
7711 PyObject * obj1 = 0 ;
7712 char * kwnames[] = {
7713 (char *) "self",(char *) "pt", NULL
7714 };
7715
7716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7718 if (!SWIG_IsOK(res1)) {
7719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7720 }
7721 arg1 = reinterpret_cast< wxRect * >(argp1);
7722 {
7723 arg2 = &temp2;
7724 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7725 }
7726 {
7727 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 {
7731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7732 }
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 wxRect *arg2 = 0 ;
7743 bool result;
7744 void *argp1 = 0 ;
7745 int res1 = 0 ;
7746 wxRect temp2 ;
7747 PyObject * obj0 = 0 ;
7748 PyObject * obj1 = 0 ;
7749 char * kwnames[] = {
7750 (char *) "self",(char *) "rect", NULL
7751 };
7752
7753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7755 if (!SWIG_IsOK(res1)) {
7756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7757 }
7758 arg1 = reinterpret_cast< wxRect * >(argp1);
7759 {
7760 arg2 = &temp2;
7761 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7762 }
7763 {
7764 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 wxRect *arg2 = 0 ;
7780 bool result;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 wxRect temp2 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "rect", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 {
7797 arg2 = &temp2;
7798 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7799 }
7800 {
7801 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7806 }
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj = 0;
7815 wxRect *arg1 = (wxRect *) 0 ;
7816 wxRect *arg2 = 0 ;
7817 int arg3 = (int) wxBOTH ;
7818 wxRect result;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 wxRect temp2 ;
7822 int val3 ;
7823 int ecode3 = 0 ;
7824 PyObject * obj0 = 0 ;
7825 PyObject * obj1 = 0 ;
7826 PyObject * obj2 = 0 ;
7827 char * kwnames[] = {
7828 (char *) "self",(char *) "r",(char *) "dir", NULL
7829 };
7830
7831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7833 if (!SWIG_IsOK(res1)) {
7834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7835 }
7836 arg1 = reinterpret_cast< wxRect * >(argp1);
7837 {
7838 arg2 = &temp2;
7839 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7840 }
7841 if (obj2) {
7842 ecode3 = SWIG_AsVal_int(obj2, &val3);
7843 if (!SWIG_IsOK(ecode3)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7845 }
7846 arg3 = static_cast< int >(val3);
7847 }
7848 {
7849 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7860 PyObject *resultobj = 0;
7861 wxRect *arg1 = (wxRect *) 0 ;
7862 int arg2 ;
7863 void *argp1 = 0 ;
7864 int res1 = 0 ;
7865 int val2 ;
7866 int ecode2 = 0 ;
7867 PyObject *swig_obj[2] ;
7868
7869 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7871 if (!SWIG_IsOK(res1)) {
7872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7873 }
7874 arg1 = reinterpret_cast< wxRect * >(argp1);
7875 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7876 if (!SWIG_IsOK(ecode2)) {
7877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7878 }
7879 arg2 = static_cast< int >(val2);
7880 if (arg1) (arg1)->x = arg2;
7881
7882 resultobj = SWIG_Py_Void();
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7890 PyObject *resultobj = 0;
7891 wxRect *arg1 = (wxRect *) 0 ;
7892 int result;
7893 void *argp1 = 0 ;
7894 int res1 = 0 ;
7895 PyObject *swig_obj[1] ;
7896
7897 if (!args) SWIG_fail;
7898 swig_obj[0] = args;
7899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7900 if (!SWIG_IsOK(res1)) {
7901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7902 }
7903 arg1 = reinterpret_cast< wxRect * >(argp1);
7904 result = (int) ((arg1)->x);
7905 resultobj = SWIG_From_int(static_cast< int >(result));
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 PyObject *resultobj = 0;
7914 wxRect *arg1 = (wxRect *) 0 ;
7915 int arg2 ;
7916 void *argp1 = 0 ;
7917 int res1 = 0 ;
7918 int val2 ;
7919 int ecode2 = 0 ;
7920 PyObject *swig_obj[2] ;
7921
7922 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7924 if (!SWIG_IsOK(res1)) {
7925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7926 }
7927 arg1 = reinterpret_cast< wxRect * >(argp1);
7928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7929 if (!SWIG_IsOK(ecode2)) {
7930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7931 }
7932 arg2 = static_cast< int >(val2);
7933 if (arg1) (arg1)->y = arg2;
7934
7935 resultobj = SWIG_Py_Void();
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7943 PyObject *resultobj = 0;
7944 wxRect *arg1 = (wxRect *) 0 ;
7945 int result;
7946 void *argp1 = 0 ;
7947 int res1 = 0 ;
7948 PyObject *swig_obj[1] ;
7949
7950 if (!args) SWIG_fail;
7951 swig_obj[0] = args;
7952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7953 if (!SWIG_IsOK(res1)) {
7954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7955 }
7956 arg1 = reinterpret_cast< wxRect * >(argp1);
7957 result = (int) ((arg1)->y);
7958 resultobj = SWIG_From_int(static_cast< int >(result));
7959 return resultobj;
7960 fail:
7961 return NULL;
7962 }
7963
7964
7965 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7966 PyObject *resultobj = 0;
7967 wxRect *arg1 = (wxRect *) 0 ;
7968 int arg2 ;
7969 void *argp1 = 0 ;
7970 int res1 = 0 ;
7971 int val2 ;
7972 int ecode2 = 0 ;
7973 PyObject *swig_obj[2] ;
7974
7975 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7977 if (!SWIG_IsOK(res1)) {
7978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7979 }
7980 arg1 = reinterpret_cast< wxRect * >(argp1);
7981 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7982 if (!SWIG_IsOK(ecode2)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7984 }
7985 arg2 = static_cast< int >(val2);
7986 if (arg1) (arg1)->width = arg2;
7987
7988 resultobj = SWIG_Py_Void();
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7996 PyObject *resultobj = 0;
7997 wxRect *arg1 = (wxRect *) 0 ;
7998 int result;
7999 void *argp1 = 0 ;
8000 int res1 = 0 ;
8001 PyObject *swig_obj[1] ;
8002
8003 if (!args) SWIG_fail;
8004 swig_obj[0] = args;
8005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8006 if (!SWIG_IsOK(res1)) {
8007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8008 }
8009 arg1 = reinterpret_cast< wxRect * >(argp1);
8010 result = (int) ((arg1)->width);
8011 resultobj = SWIG_From_int(static_cast< int >(result));
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8019 PyObject *resultobj = 0;
8020 wxRect *arg1 = (wxRect *) 0 ;
8021 int arg2 ;
8022 void *argp1 = 0 ;
8023 int res1 = 0 ;
8024 int val2 ;
8025 int ecode2 = 0 ;
8026 PyObject *swig_obj[2] ;
8027
8028 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8030 if (!SWIG_IsOK(res1)) {
8031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8032 }
8033 arg1 = reinterpret_cast< wxRect * >(argp1);
8034 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8035 if (!SWIG_IsOK(ecode2)) {
8036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8037 }
8038 arg2 = static_cast< int >(val2);
8039 if (arg1) (arg1)->height = arg2;
8040
8041 resultobj = SWIG_Py_Void();
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8049 PyObject *resultobj = 0;
8050 wxRect *arg1 = (wxRect *) 0 ;
8051 int result;
8052 void *argp1 = 0 ;
8053 int res1 = 0 ;
8054 PyObject *swig_obj[1] ;
8055
8056 if (!args) SWIG_fail;
8057 swig_obj[0] = args;
8058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8059 if (!SWIG_IsOK(res1)) {
8060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8061 }
8062 arg1 = reinterpret_cast< wxRect * >(argp1);
8063 result = (int) ((arg1)->height);
8064 resultobj = SWIG_From_int(static_cast< int >(result));
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj = 0;
8073 wxRect *arg1 = (wxRect *) 0 ;
8074 int arg2 = (int) 0 ;
8075 int arg3 = (int) 0 ;
8076 int arg4 = (int) 0 ;
8077 int arg5 = (int) 0 ;
8078 void *argp1 = 0 ;
8079 int res1 = 0 ;
8080 int val2 ;
8081 int ecode2 = 0 ;
8082 int val3 ;
8083 int ecode3 = 0 ;
8084 int val4 ;
8085 int ecode4 = 0 ;
8086 int val5 ;
8087 int ecode5 = 0 ;
8088 PyObject * obj0 = 0 ;
8089 PyObject * obj1 = 0 ;
8090 PyObject * obj2 = 0 ;
8091 PyObject * obj3 = 0 ;
8092 PyObject * obj4 = 0 ;
8093 char * kwnames[] = {
8094 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8095 };
8096
8097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8099 if (!SWIG_IsOK(res1)) {
8100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8101 }
8102 arg1 = reinterpret_cast< wxRect * >(argp1);
8103 if (obj1) {
8104 ecode2 = SWIG_AsVal_int(obj1, &val2);
8105 if (!SWIG_IsOK(ecode2)) {
8106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8107 }
8108 arg2 = static_cast< int >(val2);
8109 }
8110 if (obj2) {
8111 ecode3 = SWIG_AsVal_int(obj2, &val3);
8112 if (!SWIG_IsOK(ecode3)) {
8113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8114 }
8115 arg3 = static_cast< int >(val3);
8116 }
8117 if (obj3) {
8118 ecode4 = SWIG_AsVal_int(obj3, &val4);
8119 if (!SWIG_IsOK(ecode4)) {
8120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8121 }
8122 arg4 = static_cast< int >(val4);
8123 }
8124 if (obj4) {
8125 ecode5 = SWIG_AsVal_int(obj4, &val5);
8126 if (!SWIG_IsOK(ecode5)) {
8127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8128 }
8129 arg5 = static_cast< int >(val5);
8130 }
8131 {
8132 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 resultobj = SWIG_Py_Void();
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8143 PyObject *resultobj = 0;
8144 wxRect *arg1 = (wxRect *) 0 ;
8145 PyObject *result = 0 ;
8146 void *argp1 = 0 ;
8147 int res1 = 0 ;
8148 PyObject *swig_obj[1] ;
8149
8150 if (!args) SWIG_fail;
8151 swig_obj[0] = args;
8152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8153 if (!SWIG_IsOK(res1)) {
8154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8155 }
8156 arg1 = reinterpret_cast< wxRect * >(argp1);
8157 {
8158 result = (PyObject *)wxRect_Get(arg1);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 resultobj = result;
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169 PyObject *obj;
8170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8171 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8172 return SWIG_Py_Void();
8173 }
8174
8175 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8176 return SWIG_Python_InitShadowInstance(args);
8177 }
8178
8179 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj = 0;
8181 wxRect *arg1 = (wxRect *) 0 ;
8182 wxRect *arg2 = (wxRect *) 0 ;
8183 PyObject *result = 0 ;
8184 void *argp1 = 0 ;
8185 int res1 = 0 ;
8186 void *argp2 = 0 ;
8187 int res2 = 0 ;
8188 PyObject * obj0 = 0 ;
8189 PyObject * obj1 = 0 ;
8190 char * kwnames[] = {
8191 (char *) "r1",(char *) "r2", NULL
8192 };
8193
8194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8196 if (!SWIG_IsOK(res1)) {
8197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8198 }
8199 arg1 = reinterpret_cast< wxRect * >(argp1);
8200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8201 if (!SWIG_IsOK(res2)) {
8202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8203 }
8204 arg2 = reinterpret_cast< wxRect * >(argp2);
8205 {
8206 if (!wxPyCheckForApp()) SWIG_fail;
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (PyObject *)wxIntersectRect(arg1,arg2);
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 resultobj = result;
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj = 0;
8221 double arg1 = (double) 0.0 ;
8222 double arg2 = (double) 0.0 ;
8223 wxPoint2D *result = 0 ;
8224 double val1 ;
8225 int ecode1 = 0 ;
8226 double val2 ;
8227 int ecode2 = 0 ;
8228 PyObject * obj0 = 0 ;
8229 PyObject * obj1 = 0 ;
8230 char * kwnames[] = {
8231 (char *) "x",(char *) "y", NULL
8232 };
8233
8234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8235 if (obj0) {
8236 ecode1 = SWIG_AsVal_double(obj0, &val1);
8237 if (!SWIG_IsOK(ecode1)) {
8238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8239 }
8240 arg1 = static_cast< double >(val1);
8241 }
8242 if (obj1) {
8243 ecode2 = SWIG_AsVal_double(obj1, &val2);
8244 if (!SWIG_IsOK(ecode2)) {
8245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8246 }
8247 arg2 = static_cast< double >(val2);
8248 }
8249 {
8250 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj = 0;
8262 wxPoint2D *arg1 = 0 ;
8263 wxPoint2D *result = 0 ;
8264 wxPoint2D temp1 ;
8265 PyObject * obj0 = 0 ;
8266 char * kwnames[] = {
8267 (char *) "pt", NULL
8268 };
8269
8270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8271 {
8272 arg1 = &temp1;
8273 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8274 }
8275 {
8276 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj = 0;
8288 wxPoint *arg1 = 0 ;
8289 wxPoint2D *result = 0 ;
8290 wxPoint temp1 ;
8291 PyObject * obj0 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "pt", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8297 {
8298 arg1 = &temp1;
8299 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8300 }
8301 {
8302 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8306 return resultobj;
8307 fail:
8308 return NULL;
8309 }
8310
8311
8312 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8313 PyObject *resultobj = 0;
8314 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8315 void *argp1 = 0 ;
8316 int res1 = 0 ;
8317 PyObject *swig_obj[1] ;
8318
8319 if (!args) SWIG_fail;
8320 swig_obj[0] = args;
8321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8324 }
8325 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8326 {
8327 delete arg1;
8328
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_Py_Void();
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8339 PyObject *resultobj = 0;
8340 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8341 int *arg2 = (int *) 0 ;
8342 int *arg3 = (int *) 0 ;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 int temp2 ;
8346 int res2 = SWIG_TMPOBJ ;
8347 int temp3 ;
8348 int res3 = SWIG_TMPOBJ ;
8349 PyObject *swig_obj[1] ;
8350
8351 arg2 = &temp2;
8352 arg3 = &temp3;
8353 if (!args) SWIG_fail;
8354 swig_obj[0] = args;
8355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8356 if (!SWIG_IsOK(res1)) {
8357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8358 }
8359 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8360 {
8361 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 resultobj = SWIG_Py_Void();
8365 if (SWIG_IsTmpObj(res2)) {
8366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8367 } else {
8368 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8370 }
8371 if (SWIG_IsTmpObj(res3)) {
8372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8373 } else {
8374 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8376 }
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8384 PyObject *resultobj = 0;
8385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8386 int *arg2 = (int *) 0 ;
8387 int *arg3 = (int *) 0 ;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 int temp2 ;
8391 int res2 = SWIG_TMPOBJ ;
8392 int temp3 ;
8393 int res3 = SWIG_TMPOBJ ;
8394 PyObject *swig_obj[1] ;
8395
8396 arg2 = &temp2;
8397 arg3 = &temp3;
8398 if (!args) SWIG_fail;
8399 swig_obj[0] = args;
8400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8401 if (!SWIG_IsOK(res1)) {
8402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8403 }
8404 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8405 {
8406 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 resultobj = SWIG_Py_Void();
8410 if (SWIG_IsTmpObj(res2)) {
8411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8412 } else {
8413 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8415 }
8416 if (SWIG_IsTmpObj(res3)) {
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8418 } else {
8419 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8421 }
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8429 PyObject *resultobj = 0;
8430 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8431 double result;
8432 void *argp1 = 0 ;
8433 int res1 = 0 ;
8434 PyObject *swig_obj[1] ;
8435
8436 if (!args) SWIG_fail;
8437 swig_obj[0] = args;
8438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8439 if (!SWIG_IsOK(res1)) {
8440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8441 }
8442 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8443 {
8444 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_From_double(static_cast< double >(result));
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8455 PyObject *resultobj = 0;
8456 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8457 double result;
8458 void *argp1 = 0 ;
8459 int res1 = 0 ;
8460 PyObject *swig_obj[1] ;
8461
8462 if (!args) SWIG_fail;
8463 swig_obj[0] = args;
8464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8467 }
8468 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8469 {
8470 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 resultobj = SWIG_From_double(static_cast< double >(result));
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8481 PyObject *resultobj = 0;
8482 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8483 double arg2 ;
8484 void *argp1 = 0 ;
8485 int res1 = 0 ;
8486 double val2 ;
8487 int ecode2 = 0 ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char * kwnames[] = {
8491 (char *) "self",(char *) "length", NULL
8492 };
8493
8494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8496 if (!SWIG_IsOK(res1)) {
8497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8498 }
8499 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8500 ecode2 = SWIG_AsVal_double(obj1, &val2);
8501 if (!SWIG_IsOK(ecode2)) {
8502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8503 }
8504 arg2 = static_cast< double >(val2);
8505 {
8506 (arg1)->SetVectorLength(arg2);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_Py_Void();
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj = 0;
8518 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8519 double arg2 ;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 double val2 ;
8523 int ecode2 = 0 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 char * kwnames[] = {
8527 (char *) "self",(char *) "degrees", NULL
8528 };
8529
8530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8534 }
8535 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8536 ecode2 = SWIG_AsVal_double(obj1, &val2);
8537 if (!SWIG_IsOK(ecode2)) {
8538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8539 }
8540 arg2 = static_cast< double >(val2);
8541 {
8542 (arg1)->SetVectorAngle(arg2);
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 resultobj = SWIG_Py_Void();
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8553 PyObject *resultobj = 0;
8554 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8555 wxPoint2D *arg2 = 0 ;
8556 double result;
8557 void *argp1 = 0 ;
8558 int res1 = 0 ;
8559 wxPoint2D temp2 ;
8560 PyObject * obj0 = 0 ;
8561 PyObject * obj1 = 0 ;
8562 char * kwnames[] = {
8563 (char *) "self",(char *) "pt", NULL
8564 };
8565
8566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8568 if (!SWIG_IsOK(res1)) {
8569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8570 }
8571 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8572 {
8573 arg2 = &temp2;
8574 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8575 }
8576 {
8577 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 resultobj = SWIG_From_double(static_cast< double >(result));
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8588 PyObject *resultobj = 0;
8589 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8590 wxPoint2D *arg2 = 0 ;
8591 double result;
8592 void *argp1 = 0 ;
8593 int res1 = 0 ;
8594 wxPoint2D temp2 ;
8595 PyObject * obj0 = 0 ;
8596 PyObject * obj1 = 0 ;
8597 char * kwnames[] = {
8598 (char *) "self",(char *) "pt", NULL
8599 };
8600
8601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8603 if (!SWIG_IsOK(res1)) {
8604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8605 }
8606 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8607 {
8608 arg2 = &temp2;
8609 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8610 }
8611 {
8612 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 resultobj = SWIG_From_double(static_cast< double >(result));
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8623 PyObject *resultobj = 0;
8624 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8625 wxPoint2D *arg2 = 0 ;
8626 double result;
8627 void *argp1 = 0 ;
8628 int res1 = 0 ;
8629 wxPoint2D temp2 ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 char * kwnames[] = {
8633 (char *) "self",(char *) "vec", NULL
8634 };
8635
8636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8638 if (!SWIG_IsOK(res1)) {
8639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8640 }
8641 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8642 {
8643 arg2 = &temp2;
8644 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8645 }
8646 {
8647 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_From_double(static_cast< double >(result));
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj = 0;
8659 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8660 wxPoint2D *arg2 = 0 ;
8661 double result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 wxPoint2D temp2 ;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 char * kwnames[] = {
8668 (char *) "self",(char *) "vec", NULL
8669 };
8670
8671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8673 if (!SWIG_IsOK(res1)) {
8674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8675 }
8676 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8677 {
8678 arg2 = &temp2;
8679 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8680 }
8681 {
8682 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 resultobj = SWIG_From_double(static_cast< double >(result));
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8693 PyObject *resultobj = 0;
8694 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8695 wxPoint2D result;
8696 void *argp1 = 0 ;
8697 int res1 = 0 ;
8698 PyObject *swig_obj[1] ;
8699
8700 if (!args) SWIG_fail;
8701 swig_obj[0] = args;
8702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8705 }
8706 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8707 {
8708 result = (arg1)->operator -();
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 wxPoint2D *arg2 = 0 ;
8722 wxPoint2D *result = 0 ;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 wxPoint2D temp2 ;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 char * kwnames[] = {
8729 (char *) "self",(char *) "pt", NULL
8730 };
8731
8732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8736 }
8737 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8738 {
8739 arg2 = &temp2;
8740 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8741 }
8742 {
8743 {
8744 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8745 result = (wxPoint2D *) &_result_ref;
8746 }
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj = 0;
8758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8759 wxPoint2D *arg2 = 0 ;
8760 wxPoint2D *result = 0 ;
8761 void *argp1 = 0 ;
8762 int res1 = 0 ;
8763 wxPoint2D temp2 ;
8764 PyObject * obj0 = 0 ;
8765 PyObject * obj1 = 0 ;
8766 char * kwnames[] = {
8767 (char *) "self",(char *) "pt", NULL
8768 };
8769
8770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8772 if (!SWIG_IsOK(res1)) {
8773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8774 }
8775 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8776 {
8777 arg2 = &temp2;
8778 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8779 }
8780 {
8781 {
8782 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8783 result = (wxPoint2D *) &_result_ref;
8784 }
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj = 0;
8796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8797 wxPoint2D *arg2 = 0 ;
8798 wxPoint2D *result = 0 ;
8799 void *argp1 = 0 ;
8800 int res1 = 0 ;
8801 wxPoint2D temp2 ;
8802 PyObject * obj0 = 0 ;
8803 PyObject * obj1 = 0 ;
8804 char * kwnames[] = {
8805 (char *) "self",(char *) "pt", NULL
8806 };
8807
8808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8812 }
8813 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8814 {
8815 arg2 = &temp2;
8816 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8817 }
8818 {
8819 {
8820 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8821 result = (wxPoint2D *) &_result_ref;
8822 }
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj = 0;
8834 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8835 wxPoint2D *arg2 = 0 ;
8836 wxPoint2D *result = 0 ;
8837 void *argp1 = 0 ;
8838 int res1 = 0 ;
8839 wxPoint2D temp2 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 char * kwnames[] = {
8843 (char *) "self",(char *) "pt", NULL
8844 };
8845
8846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8850 }
8851 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8852 {
8853 arg2 = &temp2;
8854 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8855 }
8856 {
8857 {
8858 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8859 result = (wxPoint2D *) &_result_ref;
8860 }
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8864 return resultobj;
8865 fail:
8866 return NULL;
8867 }
8868
8869
8870 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8871 PyObject *resultobj = 0;
8872 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8873 PyObject *arg2 = (PyObject *) 0 ;
8874 bool result;
8875 void *argp1 = 0 ;
8876 int res1 = 0 ;
8877 PyObject * obj0 = 0 ;
8878 PyObject * obj1 = 0 ;
8879 char * kwnames[] = {
8880 (char *) "self",(char *) "other", NULL
8881 };
8882
8883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8887 }
8888 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8889 arg2 = obj1;
8890 {
8891 result = (bool)wxPoint2D___eq__(arg1,arg2);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 {
8895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8896 }
8897 return resultobj;
8898 fail:
8899 return NULL;
8900 }
8901
8902
8903 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8904 PyObject *resultobj = 0;
8905 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8906 PyObject *arg2 = (PyObject *) 0 ;
8907 bool result;
8908 void *argp1 = 0 ;
8909 int res1 = 0 ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 char * kwnames[] = {
8913 (char *) "self",(char *) "other", NULL
8914 };
8915
8916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8918 if (!SWIG_IsOK(res1)) {
8919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8920 }
8921 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8922 arg2 = obj1;
8923 {
8924 result = (bool)wxPoint2D___ne__(arg1,arg2);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 {
8928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8929 }
8930 return resultobj;
8931 fail:
8932 return NULL;
8933 }
8934
8935
8936 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8937 PyObject *resultobj = 0;
8938 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8939 double arg2 ;
8940 void *argp1 = 0 ;
8941 int res1 = 0 ;
8942 double val2 ;
8943 int ecode2 = 0 ;
8944 PyObject *swig_obj[2] ;
8945
8946 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8948 if (!SWIG_IsOK(res1)) {
8949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8950 }
8951 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8952 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8953 if (!SWIG_IsOK(ecode2)) {
8954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8955 }
8956 arg2 = static_cast< double >(val2);
8957 if (arg1) (arg1)->m_x = arg2;
8958
8959 resultobj = SWIG_Py_Void();
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8967 PyObject *resultobj = 0;
8968 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8969 double result;
8970 void *argp1 = 0 ;
8971 int res1 = 0 ;
8972 PyObject *swig_obj[1] ;
8973
8974 if (!args) SWIG_fail;
8975 swig_obj[0] = args;
8976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8977 if (!SWIG_IsOK(res1)) {
8978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8979 }
8980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8981 result = (double) ((arg1)->m_x);
8982 resultobj = SWIG_From_double(static_cast< double >(result));
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990 PyObject *resultobj = 0;
8991 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8992 double arg2 ;
8993 void *argp1 = 0 ;
8994 int res1 = 0 ;
8995 double val2 ;
8996 int ecode2 = 0 ;
8997 PyObject *swig_obj[2] ;
8998
8999 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9001 if (!SWIG_IsOK(res1)) {
9002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9003 }
9004 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9005 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9006 if (!SWIG_IsOK(ecode2)) {
9007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9008 }
9009 arg2 = static_cast< double >(val2);
9010 if (arg1) (arg1)->m_y = arg2;
9011
9012 resultobj = SWIG_Py_Void();
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9020 PyObject *resultobj = 0;
9021 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9022 double result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject *swig_obj[1] ;
9026
9027 if (!args) SWIG_fail;
9028 swig_obj[0] = args;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9032 }
9033 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9034 result = (double) ((arg1)->m_y);
9035 resultobj = SWIG_From_double(static_cast< double >(result));
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj = 0;
9044 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9045 double arg2 = (double) 0 ;
9046 double arg3 = (double) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 double val2 ;
9050 int ecode2 = 0 ;
9051 double val3 ;
9052 int ecode3 = 0 ;
9053 PyObject * obj0 = 0 ;
9054 PyObject * obj1 = 0 ;
9055 PyObject * obj2 = 0 ;
9056 char * kwnames[] = {
9057 (char *) "self",(char *) "x",(char *) "y", NULL
9058 };
9059
9060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9062 if (!SWIG_IsOK(res1)) {
9063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9064 }
9065 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9066 if (obj1) {
9067 ecode2 = SWIG_AsVal_double(obj1, &val2);
9068 if (!SWIG_IsOK(ecode2)) {
9069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9070 }
9071 arg2 = static_cast< double >(val2);
9072 }
9073 if (obj2) {
9074 ecode3 = SWIG_AsVal_double(obj2, &val3);
9075 if (!SWIG_IsOK(ecode3)) {
9076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9077 }
9078 arg3 = static_cast< double >(val3);
9079 }
9080 {
9081 wxPoint2D_Set(arg1,arg2,arg3);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 resultobj = SWIG_Py_Void();
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9092 PyObject *resultobj = 0;
9093 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9094 PyObject *result = 0 ;
9095 void *argp1 = 0 ;
9096 int res1 = 0 ;
9097 PyObject *swig_obj[1] ;
9098
9099 if (!args) SWIG_fail;
9100 swig_obj[0] = args;
9101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9106 {
9107 result = (PyObject *)wxPoint2D_Get(arg1);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 resultobj = result;
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9118 PyObject *obj;
9119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9120 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9121 return SWIG_Py_Void();
9122 }
9123
9124 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9125 return SWIG_Python_InitShadowInstance(args);
9126 }
9127
9128 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj = 0;
9130 wxDouble arg1 = (wxDouble) 0.0 ;
9131 wxDouble arg2 = (wxDouble) 0.0 ;
9132 wxDouble arg3 = (wxDouble) 0.0 ;
9133 wxDouble arg4 = (wxDouble) 0.0 ;
9134 wxRect2D *result = 0 ;
9135 void *argp1 ;
9136 int res1 = 0 ;
9137 void *argp2 ;
9138 int res2 = 0 ;
9139 void *argp3 ;
9140 int res3 = 0 ;
9141 void *argp4 ;
9142 int res4 = 0 ;
9143 PyObject * obj0 = 0 ;
9144 PyObject * obj1 = 0 ;
9145 PyObject * obj2 = 0 ;
9146 PyObject * obj3 = 0 ;
9147 char * kwnames[] = {
9148 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9149 };
9150
9151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9152 if (obj0) {
9153 {
9154 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9155 if (!SWIG_IsOK(res1)) {
9156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9157 }
9158 if (!argp1) {
9159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9160 } else {
9161 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9162 arg1 = *temp;
9163 if (SWIG_IsNewObj(res1)) delete temp;
9164 }
9165 }
9166 }
9167 if (obj1) {
9168 {
9169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9170 if (!SWIG_IsOK(res2)) {
9171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9172 }
9173 if (!argp2) {
9174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9175 } else {
9176 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9177 arg2 = *temp;
9178 if (SWIG_IsNewObj(res2)) delete temp;
9179 }
9180 }
9181 }
9182 if (obj2) {
9183 {
9184 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9185 if (!SWIG_IsOK(res3)) {
9186 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9187 }
9188 if (!argp3) {
9189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9190 } else {
9191 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9192 arg3 = *temp;
9193 if (SWIG_IsNewObj(res3)) delete temp;
9194 }
9195 }
9196 }
9197 if (obj3) {
9198 {
9199 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9200 if (!SWIG_IsOK(res4)) {
9201 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9202 }
9203 if (!argp4) {
9204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9205 } else {
9206 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9207 arg4 = *temp;
9208 if (SWIG_IsNewObj(res4)) delete temp;
9209 }
9210 }
9211 }
9212 {
9213 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9214 if (PyErr_Occurred()) SWIG_fail;
9215 }
9216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9217 return resultobj;
9218 fail:
9219 return NULL;
9220 }
9221
9222
9223 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9224 PyObject *resultobj = 0;
9225 wxRect2D *arg1 = (wxRect2D *) 0 ;
9226 void *argp1 = 0 ;
9227 int res1 = 0 ;
9228 PyObject *swig_obj[1] ;
9229
9230 if (!args) SWIG_fail;
9231 swig_obj[0] = args;
9232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9235 }
9236 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9237 {
9238 delete arg1;
9239
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 resultobj = SWIG_Py_Void();
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9250 PyObject *resultobj = 0;
9251 wxRect2D *arg1 = (wxRect2D *) 0 ;
9252 wxPoint2D result;
9253 void *argp1 = 0 ;
9254 int res1 = 0 ;
9255 PyObject *swig_obj[1] ;
9256
9257 if (!args) SWIG_fail;
9258 swig_obj[0] = args;
9259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9260 if (!SWIG_IsOK(res1)) {
9261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9262 }
9263 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9264 {
9265 result = (arg1)->GetPosition();
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *resultobj = 0;
9277 wxRect2D *arg1 = (wxRect2D *) 0 ;
9278 wxSize result;
9279 void *argp1 = 0 ;
9280 int res1 = 0 ;
9281 PyObject *swig_obj[1] ;
9282
9283 if (!args) SWIG_fail;
9284 swig_obj[0] = args;
9285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9286 if (!SWIG_IsOK(res1)) {
9287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9288 }
9289 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9290 {
9291 result = (arg1)->GetSize();
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9302 PyObject *resultobj = 0;
9303 wxRect2D *arg1 = (wxRect2D *) 0 ;
9304 wxDouble result;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9314 }
9315 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9316 {
9317 result = ((wxRect2D const *)arg1)->GetLeft();
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9328 PyObject *resultobj = 0;
9329 wxRect2D *arg1 = (wxRect2D *) 0 ;
9330 wxDouble arg2 ;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 void *argp2 ;
9334 int res2 = 0 ;
9335 PyObject * obj0 = 0 ;
9336 PyObject * obj1 = 0 ;
9337 char * kwnames[] = {
9338 (char *) "self",(char *) "n", NULL
9339 };
9340
9341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9345 }
9346 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9347 {
9348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9349 if (!SWIG_IsOK(res2)) {
9350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9351 }
9352 if (!argp2) {
9353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9354 } else {
9355 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9356 arg2 = *temp;
9357 if (SWIG_IsNewObj(res2)) delete temp;
9358 }
9359 }
9360 {
9361 (arg1)->SetLeft(arg2);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9372 PyObject *resultobj = 0;
9373 wxRect2D *arg1 = (wxRect2D *) 0 ;
9374 wxDouble arg2 ;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 void *argp2 ;
9378 int res2 = 0 ;
9379 PyObject * obj0 = 0 ;
9380 PyObject * obj1 = 0 ;
9381 char * kwnames[] = {
9382 (char *) "self",(char *) "n", NULL
9383 };
9384
9385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9389 }
9390 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9391 {
9392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9393 if (!SWIG_IsOK(res2)) {
9394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9395 }
9396 if (!argp2) {
9397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9398 } else {
9399 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9400 arg2 = *temp;
9401 if (SWIG_IsNewObj(res2)) delete temp;
9402 }
9403 }
9404 {
9405 (arg1)->MoveLeftTo(arg2);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_Py_Void();
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxRect2D *arg1 = (wxRect2D *) 0 ;
9418 wxDouble result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9428 }
9429 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9430 {
9431 result = ((wxRect2D const *)arg1)->GetTop();
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj = 0;
9443 wxRect2D *arg1 = (wxRect2D *) 0 ;
9444 wxDouble arg2 ;
9445 void *argp1 = 0 ;
9446 int res1 = 0 ;
9447 void *argp2 ;
9448 int res2 = 0 ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 char * kwnames[] = {
9452 (char *) "self",(char *) "n", NULL
9453 };
9454
9455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9457 if (!SWIG_IsOK(res1)) {
9458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9459 }
9460 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9461 {
9462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9463 if (!SWIG_IsOK(res2)) {
9464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9465 }
9466 if (!argp2) {
9467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9468 } else {
9469 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9470 arg2 = *temp;
9471 if (SWIG_IsNewObj(res2)) delete temp;
9472 }
9473 }
9474 {
9475 (arg1)->SetTop(arg2);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_Py_Void();
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9486 PyObject *resultobj = 0;
9487 wxRect2D *arg1 = (wxRect2D *) 0 ;
9488 wxDouble arg2 ;
9489 void *argp1 = 0 ;
9490 int res1 = 0 ;
9491 void *argp2 ;
9492 int res2 = 0 ;
9493 PyObject * obj0 = 0 ;
9494 PyObject * obj1 = 0 ;
9495 char * kwnames[] = {
9496 (char *) "self",(char *) "n", NULL
9497 };
9498
9499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9501 if (!SWIG_IsOK(res1)) {
9502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9503 }
9504 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9505 {
9506 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9507 if (!SWIG_IsOK(res2)) {
9508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9509 }
9510 if (!argp2) {
9511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9512 } else {
9513 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9514 arg2 = *temp;
9515 if (SWIG_IsNewObj(res2)) delete temp;
9516 }
9517 }
9518 {
9519 (arg1)->MoveTopTo(arg2);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 resultobj = SWIG_Py_Void();
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9530 PyObject *resultobj = 0;
9531 wxRect2D *arg1 = (wxRect2D *) 0 ;
9532 wxDouble result;
9533 void *argp1 = 0 ;
9534 int res1 = 0 ;
9535 PyObject *swig_obj[1] ;
9536
9537 if (!args) SWIG_fail;
9538 swig_obj[0] = args;
9539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9540 if (!SWIG_IsOK(res1)) {
9541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9542 }
9543 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9544 {
9545 result = ((wxRect2D const *)arg1)->GetBottom();
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj = 0;
9557 wxRect2D *arg1 = (wxRect2D *) 0 ;
9558 wxDouble arg2 ;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 void *argp2 ;
9562 int res2 = 0 ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char * kwnames[] = {
9566 (char *) "self",(char *) "n", NULL
9567 };
9568
9569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9571 if (!SWIG_IsOK(res1)) {
9572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9573 }
9574 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9575 {
9576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9577 if (!SWIG_IsOK(res2)) {
9578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9579 }
9580 if (!argp2) {
9581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9582 } else {
9583 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9584 arg2 = *temp;
9585 if (SWIG_IsNewObj(res2)) delete temp;
9586 }
9587 }
9588 {
9589 (arg1)->SetBottom(arg2);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_Py_Void();
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj = 0;
9601 wxRect2D *arg1 = (wxRect2D *) 0 ;
9602 wxDouble arg2 ;
9603 void *argp1 = 0 ;
9604 int res1 = 0 ;
9605 void *argp2 ;
9606 int res2 = 0 ;
9607 PyObject * obj0 = 0 ;
9608 PyObject * obj1 = 0 ;
9609 char * kwnames[] = {
9610 (char *) "self",(char *) "n", NULL
9611 };
9612
9613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9615 if (!SWIG_IsOK(res1)) {
9616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9617 }
9618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9619 {
9620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9621 if (!SWIG_IsOK(res2)) {
9622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9623 }
9624 if (!argp2) {
9625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9626 } else {
9627 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9628 arg2 = *temp;
9629 if (SWIG_IsNewObj(res2)) delete temp;
9630 }
9631 }
9632 {
9633 (arg1)->MoveBottomTo(arg2);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 resultobj = SWIG_Py_Void();
9637 return resultobj;
9638 fail:
9639 return NULL;
9640 }
9641
9642
9643 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9644 PyObject *resultobj = 0;
9645 wxRect2D *arg1 = (wxRect2D *) 0 ;
9646 wxDouble result;
9647 void *argp1 = 0 ;
9648 int res1 = 0 ;
9649 PyObject *swig_obj[1] ;
9650
9651 if (!args) SWIG_fail;
9652 swig_obj[0] = args;
9653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9654 if (!SWIG_IsOK(res1)) {
9655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9656 }
9657 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9658 {
9659 result = ((wxRect2D const *)arg1)->GetRight();
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9670 PyObject *resultobj = 0;
9671 wxRect2D *arg1 = (wxRect2D *) 0 ;
9672 wxDouble arg2 ;
9673 void *argp1 = 0 ;
9674 int res1 = 0 ;
9675 void *argp2 ;
9676 int res2 = 0 ;
9677 PyObject * obj0 = 0 ;
9678 PyObject * obj1 = 0 ;
9679 char * kwnames[] = {
9680 (char *) "self",(char *) "n", NULL
9681 };
9682
9683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9685 if (!SWIG_IsOK(res1)) {
9686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9687 }
9688 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9689 {
9690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9691 if (!SWIG_IsOK(res2)) {
9692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9693 }
9694 if (!argp2) {
9695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9696 } else {
9697 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9698 arg2 = *temp;
9699 if (SWIG_IsNewObj(res2)) delete temp;
9700 }
9701 }
9702 {
9703 (arg1)->SetRight(arg2);
9704 if (PyErr_Occurred()) SWIG_fail;
9705 }
9706 resultobj = SWIG_Py_Void();
9707 return resultobj;
9708 fail:
9709 return NULL;
9710 }
9711
9712
9713 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9714 PyObject *resultobj = 0;
9715 wxRect2D *arg1 = (wxRect2D *) 0 ;
9716 wxDouble arg2 ;
9717 void *argp1 = 0 ;
9718 int res1 = 0 ;
9719 void *argp2 ;
9720 int res2 = 0 ;
9721 PyObject * obj0 = 0 ;
9722 PyObject * obj1 = 0 ;
9723 char * kwnames[] = {
9724 (char *) "self",(char *) "n", NULL
9725 };
9726
9727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9731 }
9732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9733 {
9734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9735 if (!SWIG_IsOK(res2)) {
9736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9737 }
9738 if (!argp2) {
9739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9740 } else {
9741 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9742 arg2 = *temp;
9743 if (SWIG_IsNewObj(res2)) delete temp;
9744 }
9745 }
9746 {
9747 (arg1)->MoveRightTo(arg2);
9748 if (PyErr_Occurred()) SWIG_fail;
9749 }
9750 resultobj = SWIG_Py_Void();
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 PyObject *resultobj = 0;
9759 wxRect2D *arg1 = (wxRect2D *) 0 ;
9760 wxPoint2D result;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 PyObject *swig_obj[1] ;
9764
9765 if (!args) SWIG_fail;
9766 swig_obj[0] = args;
9767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9770 }
9771 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9772 {
9773 result = ((wxRect2D const *)arg1)->GetLeftTop();
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj = 0;
9785 wxRect2D *arg1 = (wxRect2D *) 0 ;
9786 wxPoint2D *arg2 = 0 ;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 wxPoint2D temp2 ;
9790 PyObject * obj0 = 0 ;
9791 PyObject * obj1 = 0 ;
9792 char * kwnames[] = {
9793 (char *) "self",(char *) "pt", NULL
9794 };
9795
9796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9798 if (!SWIG_IsOK(res1)) {
9799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9800 }
9801 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9802 {
9803 arg2 = &temp2;
9804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9805 }
9806 {
9807 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 resultobj = SWIG_Py_Void();
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj = 0;
9819 wxRect2D *arg1 = (wxRect2D *) 0 ;
9820 wxPoint2D *arg2 = 0 ;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 wxPoint2D temp2 ;
9824 PyObject * obj0 = 0 ;
9825 PyObject * obj1 = 0 ;
9826 char * kwnames[] = {
9827 (char *) "self",(char *) "pt", NULL
9828 };
9829
9830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9832 if (!SWIG_IsOK(res1)) {
9833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9834 }
9835 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9836 {
9837 arg2 = &temp2;
9838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9839 }
9840 {
9841 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 resultobj = SWIG_Py_Void();
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9852 PyObject *resultobj = 0;
9853 wxRect2D *arg1 = (wxRect2D *) 0 ;
9854 wxPoint2D result;
9855 void *argp1 = 0 ;
9856 int res1 = 0 ;
9857 PyObject *swig_obj[1] ;
9858
9859 if (!args) SWIG_fail;
9860 swig_obj[0] = args;
9861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9862 if (!SWIG_IsOK(res1)) {
9863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9864 }
9865 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9866 {
9867 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9871 return resultobj;
9872 fail:
9873 return NULL;
9874 }
9875
9876
9877 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9878 PyObject *resultobj = 0;
9879 wxRect2D *arg1 = (wxRect2D *) 0 ;
9880 wxPoint2D *arg2 = 0 ;
9881 void *argp1 = 0 ;
9882 int res1 = 0 ;
9883 wxPoint2D temp2 ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 char * kwnames[] = {
9887 (char *) "self",(char *) "pt", NULL
9888 };
9889
9890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9894 }
9895 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9896 {
9897 arg2 = &temp2;
9898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9899 }
9900 {
9901 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 resultobj = SWIG_Py_Void();
9905 return resultobj;
9906 fail:
9907 return NULL;
9908 }
9909
9910
9911 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9912 PyObject *resultobj = 0;
9913 wxRect2D *arg1 = (wxRect2D *) 0 ;
9914 wxPoint2D *arg2 = 0 ;
9915 void *argp1 = 0 ;
9916 int res1 = 0 ;
9917 wxPoint2D temp2 ;
9918 PyObject * obj0 = 0 ;
9919 PyObject * obj1 = 0 ;
9920 char * kwnames[] = {
9921 (char *) "self",(char *) "pt", NULL
9922 };
9923
9924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9926 if (!SWIG_IsOK(res1)) {
9927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9928 }
9929 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9930 {
9931 arg2 = &temp2;
9932 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9933 }
9934 {
9935 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_Py_Void();
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *resultobj = 0;
9947 wxRect2D *arg1 = (wxRect2D *) 0 ;
9948 wxPoint2D result;
9949 void *argp1 = 0 ;
9950 int res1 = 0 ;
9951 PyObject *swig_obj[1] ;
9952
9953 if (!args) SWIG_fail;
9954 swig_obj[0] = args;
9955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9956 if (!SWIG_IsOK(res1)) {
9957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9958 }
9959 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9960 {
9961 result = ((wxRect2D const *)arg1)->GetRightTop();
9962 if (PyErr_Occurred()) SWIG_fail;
9963 }
9964 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9965 return resultobj;
9966 fail:
9967 return NULL;
9968 }
9969
9970
9971 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9972 PyObject *resultobj = 0;
9973 wxRect2D *arg1 = (wxRect2D *) 0 ;
9974 wxPoint2D *arg2 = 0 ;
9975 void *argp1 = 0 ;
9976 int res1 = 0 ;
9977 wxPoint2D temp2 ;
9978 PyObject * obj0 = 0 ;
9979 PyObject * obj1 = 0 ;
9980 char * kwnames[] = {
9981 (char *) "self",(char *) "pt", NULL
9982 };
9983
9984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9988 }
9989 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9990 {
9991 arg2 = &temp2;
9992 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9993 }
9994 {
9995 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 resultobj = SWIG_Py_Void();
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj = 0;
10007 wxRect2D *arg1 = (wxRect2D *) 0 ;
10008 wxPoint2D *arg2 = 0 ;
10009 void *argp1 = 0 ;
10010 int res1 = 0 ;
10011 wxPoint2D temp2 ;
10012 PyObject * obj0 = 0 ;
10013 PyObject * obj1 = 0 ;
10014 char * kwnames[] = {
10015 (char *) "self",(char *) "pt", NULL
10016 };
10017
10018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10020 if (!SWIG_IsOK(res1)) {
10021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10022 }
10023 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10024 {
10025 arg2 = &temp2;
10026 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10027 }
10028 {
10029 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 resultobj = SWIG_Py_Void();
10033 return resultobj;
10034 fail:
10035 return NULL;
10036 }
10037
10038
10039 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10040 PyObject *resultobj = 0;
10041 wxRect2D *arg1 = (wxRect2D *) 0 ;
10042 wxPoint2D result;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 PyObject *swig_obj[1] ;
10046
10047 if (!args) SWIG_fail;
10048 swig_obj[0] = args;
10049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10050 if (!SWIG_IsOK(res1)) {
10051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10052 }
10053 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10054 {
10055 result = ((wxRect2D const *)arg1)->GetRightBottom();
10056 if (PyErr_Occurred()) SWIG_fail;
10057 }
10058 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10059 return resultobj;
10060 fail:
10061 return NULL;
10062 }
10063
10064
10065 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj = 0;
10067 wxRect2D *arg1 = (wxRect2D *) 0 ;
10068 wxPoint2D *arg2 = 0 ;
10069 void *argp1 = 0 ;
10070 int res1 = 0 ;
10071 wxPoint2D temp2 ;
10072 PyObject * obj0 = 0 ;
10073 PyObject * obj1 = 0 ;
10074 char * kwnames[] = {
10075 (char *) "self",(char *) "pt", NULL
10076 };
10077
10078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10080 if (!SWIG_IsOK(res1)) {
10081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10082 }
10083 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10084 {
10085 arg2 = &temp2;
10086 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10087 }
10088 {
10089 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 resultobj = SWIG_Py_Void();
10093 return resultobj;
10094 fail:
10095 return NULL;
10096 }
10097
10098
10099 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj = 0;
10101 wxRect2D *arg1 = (wxRect2D *) 0 ;
10102 wxPoint2D *arg2 = 0 ;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 wxPoint2D temp2 ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "pt", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10116 }
10117 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10118 {
10119 arg2 = &temp2;
10120 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10121 }
10122 {
10123 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 resultobj = SWIG_Py_Void();
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 PyObject *resultobj = 0;
10135 wxRect2D *arg1 = (wxRect2D *) 0 ;
10136 wxPoint2D result;
10137 void *argp1 = 0 ;
10138 int res1 = 0 ;
10139 PyObject *swig_obj[1] ;
10140
10141 if (!args) SWIG_fail;
10142 swig_obj[0] = args;
10143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10144 if (!SWIG_IsOK(res1)) {
10145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10146 }
10147 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10148 {
10149 result = ((wxRect2D const *)arg1)->GetCentre();
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10160 PyObject *resultobj = 0;
10161 wxRect2D *arg1 = (wxRect2D *) 0 ;
10162 wxPoint2D *arg2 = 0 ;
10163 void *argp1 = 0 ;
10164 int res1 = 0 ;
10165 wxPoint2D temp2 ;
10166 PyObject * obj0 = 0 ;
10167 PyObject * obj1 = 0 ;
10168 char * kwnames[] = {
10169 (char *) "self",(char *) "pt", NULL
10170 };
10171
10172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10174 if (!SWIG_IsOK(res1)) {
10175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10176 }
10177 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10178 {
10179 arg2 = &temp2;
10180 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10181 }
10182 {
10183 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10184 if (PyErr_Occurred()) SWIG_fail;
10185 }
10186 resultobj = SWIG_Py_Void();
10187 return resultobj;
10188 fail:
10189 return NULL;
10190 }
10191
10192
10193 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10194 PyObject *resultobj = 0;
10195 wxRect2D *arg1 = (wxRect2D *) 0 ;
10196 wxPoint2D *arg2 = 0 ;
10197 void *argp1 = 0 ;
10198 int res1 = 0 ;
10199 wxPoint2D temp2 ;
10200 PyObject * obj0 = 0 ;
10201 PyObject * obj1 = 0 ;
10202 char * kwnames[] = {
10203 (char *) "self",(char *) "pt", NULL
10204 };
10205
10206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10208 if (!SWIG_IsOK(res1)) {
10209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10210 }
10211 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10212 {
10213 arg2 = &temp2;
10214 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10215 }
10216 {
10217 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 resultobj = SWIG_Py_Void();
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 wxRect2D *arg1 = (wxRect2D *) 0 ;
10230 wxPoint2D *arg2 = 0 ;
10231 wxOutCode result;
10232 void *argp1 = 0 ;
10233 int res1 = 0 ;
10234 wxPoint2D temp2 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "pt", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10245 }
10246 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10247 {
10248 arg2 = &temp2;
10249 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10250 }
10251 {
10252 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 resultobj = SWIG_From_int(static_cast< int >(result));
10256 return resultobj;
10257 fail:
10258 return NULL;
10259 }
10260
10261
10262 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10263 PyObject *resultobj = 0;
10264 wxRect2D *arg1 = (wxRect2D *) 0 ;
10265 wxPoint2D *arg2 = 0 ;
10266 bool result;
10267 void *argp1 = 0 ;
10268 int res1 = 0 ;
10269 wxPoint2D temp2 ;
10270 PyObject * obj0 = 0 ;
10271 PyObject * obj1 = 0 ;
10272 char * kwnames[] = {
10273 (char *) "self",(char *) "pt", NULL
10274 };
10275
10276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10278 if (!SWIG_IsOK(res1)) {
10279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10280 }
10281 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10282 {
10283 arg2 = &temp2;
10284 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10285 }
10286 {
10287 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 {
10291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10292 }
10293 return resultobj;
10294 fail:
10295 return NULL;
10296 }
10297
10298
10299 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10300 PyObject *resultobj = 0;
10301 wxRect2D *arg1 = (wxRect2D *) 0 ;
10302 wxRect2D *arg2 = 0 ;
10303 bool result;
10304 void *argp1 = 0 ;
10305 int res1 = 0 ;
10306 wxRect2D temp2 ;
10307 PyObject * obj0 = 0 ;
10308 PyObject * obj1 = 0 ;
10309 char * kwnames[] = {
10310 (char *) "self",(char *) "rect", NULL
10311 };
10312
10313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10315 if (!SWIG_IsOK(res1)) {
10316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10317 }
10318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10319 {
10320 arg2 = &temp2;
10321 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10322 }
10323 {
10324 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10325 if (PyErr_Occurred()) SWIG_fail;
10326 }
10327 {
10328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10329 }
10330 return resultobj;
10331 fail:
10332 return NULL;
10333 }
10334
10335
10336 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10337 PyObject *resultobj = 0;
10338 wxRect2D *arg1 = (wxRect2D *) 0 ;
10339 bool result;
10340 void *argp1 = 0 ;
10341 int res1 = 0 ;
10342 PyObject *swig_obj[1] ;
10343
10344 if (!args) SWIG_fail;
10345 swig_obj[0] = args;
10346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10349 }
10350 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10351 {
10352 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10353 if (PyErr_Occurred()) SWIG_fail;
10354 }
10355 {
10356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10357 }
10358 return resultobj;
10359 fail:
10360 return NULL;
10361 }
10362
10363
10364 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10365 PyObject *resultobj = 0;
10366 wxRect2D *arg1 = (wxRect2D *) 0 ;
10367 wxRect2D *arg2 = 0 ;
10368 bool result;
10369 void *argp1 = 0 ;
10370 int res1 = 0 ;
10371 wxRect2D temp2 ;
10372 PyObject * obj0 = 0 ;
10373 PyObject * obj1 = 0 ;
10374 char * kwnames[] = {
10375 (char *) "self",(char *) "rect", NULL
10376 };
10377
10378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10380 if (!SWIG_IsOK(res1)) {
10381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10382 }
10383 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10384 {
10385 arg2 = &temp2;
10386 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10387 }
10388 {
10389 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 {
10393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10394 }
10395 return resultobj;
10396 fail:
10397 return NULL;
10398 }
10399
10400
10401 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10402 PyObject *resultobj = 0;
10403 wxRect2D *arg1 = (wxRect2D *) 0 ;
10404 wxDouble arg2 ;
10405 wxDouble arg3 ;
10406 void *argp1 = 0 ;
10407 int res1 = 0 ;
10408 void *argp2 ;
10409 int res2 = 0 ;
10410 void *argp3 ;
10411 int res3 = 0 ;
10412
10413 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10415 if (!SWIG_IsOK(res1)) {
10416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10417 }
10418 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10419 {
10420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10421 if (!SWIG_IsOK(res2)) {
10422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10423 }
10424 if (!argp2) {
10425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10426 } else {
10427 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10428 arg2 = *temp;
10429 if (SWIG_IsNewObj(res2)) delete temp;
10430 }
10431 }
10432 {
10433 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10434 if (!SWIG_IsOK(res3)) {
10435 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10436 }
10437 if (!argp3) {
10438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10439 } else {
10440 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10441 arg3 = *temp;
10442 if (SWIG_IsNewObj(res3)) delete temp;
10443 }
10444 }
10445 {
10446 (arg1)->Inset(arg2,arg3);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 resultobj = SWIG_Py_Void();
10450 return resultobj;
10451 fail:
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10457 PyObject *resultobj = 0;
10458 wxRect2D *arg1 = (wxRect2D *) 0 ;
10459 wxDouble arg2 ;
10460 wxDouble arg3 ;
10461 wxDouble arg4 ;
10462 wxDouble arg5 ;
10463 void *argp1 = 0 ;
10464 int res1 = 0 ;
10465 void *argp2 ;
10466 int res2 = 0 ;
10467 void *argp3 ;
10468 int res3 = 0 ;
10469 void *argp4 ;
10470 int res4 = 0 ;
10471 void *argp5 ;
10472 int res5 = 0 ;
10473
10474 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10476 if (!SWIG_IsOK(res1)) {
10477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10478 }
10479 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10480 {
10481 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10482 if (!SWIG_IsOK(res2)) {
10483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10484 }
10485 if (!argp2) {
10486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10487 } else {
10488 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10489 arg2 = *temp;
10490 if (SWIG_IsNewObj(res2)) delete temp;
10491 }
10492 }
10493 {
10494 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10495 if (!SWIG_IsOK(res3)) {
10496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10497 }
10498 if (!argp3) {
10499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10500 } else {
10501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10502 arg3 = *temp;
10503 if (SWIG_IsNewObj(res3)) delete temp;
10504 }
10505 }
10506 {
10507 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10508 if (!SWIG_IsOK(res4)) {
10509 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10510 }
10511 if (!argp4) {
10512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10513 } else {
10514 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10515 arg4 = *temp;
10516 if (SWIG_IsNewObj(res4)) delete temp;
10517 }
10518 }
10519 {
10520 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10521 if (!SWIG_IsOK(res5)) {
10522 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10523 }
10524 if (!argp5) {
10525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10526 } else {
10527 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10528 arg5 = *temp;
10529 if (SWIG_IsNewObj(res5)) delete temp;
10530 }
10531 }
10532 {
10533 (arg1)->Inset(arg2,arg3,arg4,arg5);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 resultobj = SWIG_Py_Void();
10537 return resultobj;
10538 fail:
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10544 int argc;
10545 PyObject *argv[6];
10546
10547 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10548 --argc;
10549 if (argc == 3) {
10550 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10551 }
10552 if (argc == 5) {
10553 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10554 }
10555
10556 fail:
10557 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10558 return NULL;
10559 }
10560
10561
10562 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10563 PyObject *resultobj = 0;
10564 wxRect2D *arg1 = (wxRect2D *) 0 ;
10565 wxPoint2D *arg2 = 0 ;
10566 void *argp1 = 0 ;
10567 int res1 = 0 ;
10568 wxPoint2D temp2 ;
10569 PyObject * obj0 = 0 ;
10570 PyObject * obj1 = 0 ;
10571 char * kwnames[] = {
10572 (char *) "self",(char *) "pt", NULL
10573 };
10574
10575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10577 if (!SWIG_IsOK(res1)) {
10578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10579 }
10580 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10581 {
10582 arg2 = &temp2;
10583 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10584 }
10585 {
10586 (arg1)->Offset((wxPoint2D const &)*arg2);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 resultobj = SWIG_Py_Void();
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10597 PyObject *resultobj = 0;
10598 wxRect2D *arg1 = (wxRect2D *) 0 ;
10599 wxRect2D *arg2 = 0 ;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 wxRect2D temp2 ;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 char * kwnames[] = {
10606 (char *) "self",(char *) "rect", NULL
10607 };
10608
10609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10611 if (!SWIG_IsOK(res1)) {
10612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10613 }
10614 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10615 {
10616 arg2 = &temp2;
10617 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10618 }
10619 {
10620 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 resultobj = SWIG_Py_Void();
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj = 0;
10632 wxRect2D *arg1 = (wxRect2D *) 0 ;
10633 int arg2 ;
10634 int arg3 ;
10635 wxPoint2D result;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 int val2 ;
10639 int ecode2 = 0 ;
10640 int val3 ;
10641 int ecode3 = 0 ;
10642 PyObject * obj0 = 0 ;
10643 PyObject * obj1 = 0 ;
10644 PyObject * obj2 = 0 ;
10645 char * kwnames[] = {
10646 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10647 };
10648
10649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10653 }
10654 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10655 ecode2 = SWIG_AsVal_int(obj1, &val2);
10656 if (!SWIG_IsOK(ecode2)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10658 }
10659 arg2 = static_cast< int >(val2);
10660 ecode3 = SWIG_AsVal_int(obj2, &val3);
10661 if (!SWIG_IsOK(ecode3)) {
10662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10663 }
10664 arg3 = static_cast< int >(val3);
10665 {
10666 result = (arg1)->Interpolate(arg2,arg3);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10670 return resultobj;
10671 fail:
10672 return NULL;
10673 }
10674
10675
10676 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj = 0;
10678 wxRect2D *arg1 = (wxRect2D *) 0 ;
10679 wxRect2D *arg2 = 0 ;
10680 void *argp1 = 0 ;
10681 int res1 = 0 ;
10682 wxRect2D temp2 ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 char * kwnames[] = {
10686 (char *) "self",(char *) "otherRect", NULL
10687 };
10688
10689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10693 }
10694 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10695 {
10696 arg2 = &temp2;
10697 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10698 }
10699 {
10700 (arg1)->Intersect((wxRect2D const &)*arg2);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 resultobj = SWIG_Py_Void();
10704 return resultobj;
10705 fail:
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10711 PyObject *resultobj = 0;
10712 wxRect2D *arg1 = (wxRect2D *) 0 ;
10713 wxRect2D *arg2 = 0 ;
10714 wxRect2D result;
10715 void *argp1 = 0 ;
10716 int res1 = 0 ;
10717 wxRect2D temp2 ;
10718 PyObject * obj0 = 0 ;
10719 PyObject * obj1 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "otherRect", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10728 }
10729 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10730 {
10731 arg2 = &temp2;
10732 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10733 }
10734 {
10735 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj = 0;
10747 wxRect2D *arg1 = (wxRect2D *) 0 ;
10748 wxRect2D *arg2 = 0 ;
10749 bool result;
10750 void *argp1 = 0 ;
10751 int res1 = 0 ;
10752 wxRect2D temp2 ;
10753 PyObject * obj0 = 0 ;
10754 PyObject * obj1 = 0 ;
10755 char * kwnames[] = {
10756 (char *) "self",(char *) "rect", NULL
10757 };
10758
10759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10761 if (!SWIG_IsOK(res1)) {
10762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10763 }
10764 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10765 {
10766 arg2 = &temp2;
10767 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10768 }
10769 {
10770 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 {
10774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10775 }
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj = 0;
10784 wxRect2D *arg1 = (wxRect2D *) 0 ;
10785 wxRect2D *arg2 = 0 ;
10786 void *argp1 = 0 ;
10787 int res1 = 0 ;
10788 wxRect2D temp2 ;
10789 PyObject * obj0 = 0 ;
10790 PyObject * obj1 = 0 ;
10791 char * kwnames[] = {
10792 (char *) "self",(char *) "otherRect", NULL
10793 };
10794
10795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10799 }
10800 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10801 {
10802 arg2 = &temp2;
10803 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10804 }
10805 {
10806 (arg1)->Union((wxRect2D const &)*arg2);
10807 if (PyErr_Occurred()) SWIG_fail;
10808 }
10809 resultobj = SWIG_Py_Void();
10810 return resultobj;
10811 fail:
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10817 PyObject *resultobj = 0;
10818 wxRect2D *arg1 = (wxRect2D *) 0 ;
10819 wxRect2D *arg2 = 0 ;
10820 wxRect2D result;
10821 void *argp1 = 0 ;
10822 int res1 = 0 ;
10823 wxRect2D temp2 ;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 char * kwnames[] = {
10827 (char *) "self",(char *) "otherRect", NULL
10828 };
10829
10830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10832 if (!SWIG_IsOK(res1)) {
10833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10834 }
10835 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10836 {
10837 arg2 = &temp2;
10838 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10839 }
10840 {
10841 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10845 return resultobj;
10846 fail:
10847 return NULL;
10848 }
10849
10850
10851 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10852 PyObject *resultobj = 0;
10853 wxRect2D *arg1 = (wxRect2D *) 0 ;
10854 wxDouble arg2 ;
10855 void *argp1 = 0 ;
10856 int res1 = 0 ;
10857 void *argp2 ;
10858 int res2 = 0 ;
10859
10860 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10862 if (!SWIG_IsOK(res1)) {
10863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10864 }
10865 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10866 {
10867 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10868 if (!SWIG_IsOK(res2)) {
10869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10870 }
10871 if (!argp2) {
10872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10873 } else {
10874 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10875 arg2 = *temp;
10876 if (SWIG_IsNewObj(res2)) delete temp;
10877 }
10878 }
10879 {
10880 (arg1)->Scale(arg2);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10891 PyObject *resultobj = 0;
10892 wxRect2D *arg1 = (wxRect2D *) 0 ;
10893 int arg2 ;
10894 int arg3 ;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 int val2 ;
10898 int ecode2 = 0 ;
10899 int val3 ;
10900 int ecode3 = 0 ;
10901
10902 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10904 if (!SWIG_IsOK(res1)) {
10905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10906 }
10907 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10908 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10909 if (!SWIG_IsOK(ecode2)) {
10910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10911 }
10912 arg2 = static_cast< int >(val2);
10913 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10914 if (!SWIG_IsOK(ecode3)) {
10915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10916 }
10917 arg3 = static_cast< int >(val3);
10918 {
10919 (arg1)->Scale(arg2,arg3);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_Py_Void();
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10930 int argc;
10931 PyObject *argv[4];
10932
10933 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10934 --argc;
10935 if (argc == 2) {
10936 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10937 }
10938 if (argc == 3) {
10939 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10940 }
10941
10942 fail:
10943 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxRect2D *arg1 = (wxRect2D *) 0 ;
10951 PyObject *arg2 = (PyObject *) 0 ;
10952 bool result;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 char * kwnames[] = {
10958 (char *) "self",(char *) "other", NULL
10959 };
10960
10961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10965 }
10966 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10967 arg2 = obj1;
10968 {
10969 result = (bool)wxRect2D___eq__(arg1,arg2);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 {
10973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj = 0;
10983 wxRect2D *arg1 = (wxRect2D *) 0 ;
10984 PyObject *arg2 = (PyObject *) 0 ;
10985 bool result;
10986 void *argp1 = 0 ;
10987 int res1 = 0 ;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 char * kwnames[] = {
10991 (char *) "self",(char *) "other", NULL
10992 };
10993
10994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10996 if (!SWIG_IsOK(res1)) {
10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10998 }
10999 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11000 arg2 = obj1;
11001 {
11002 result = (bool)wxRect2D___ne__(arg1,arg2);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *resultobj = 0;
11016 wxRect2D *arg1 = (wxRect2D *) 0 ;
11017 wxDouble arg2 ;
11018 void *argp1 = 0 ;
11019 int res1 = 0 ;
11020 void *argp2 ;
11021 int res2 = 0 ;
11022 PyObject *swig_obj[2] ;
11023
11024 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11026 if (!SWIG_IsOK(res1)) {
11027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11028 }
11029 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11030 {
11031 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11032 if (!SWIG_IsOK(res2)) {
11033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11034 }
11035 if (!argp2) {
11036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11037 } else {
11038 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11039 arg2 = *temp;
11040 if (SWIG_IsNewObj(res2)) delete temp;
11041 }
11042 }
11043 if (arg1) (arg1)->m_x = arg2;
11044
11045 resultobj = SWIG_Py_Void();
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11053 PyObject *resultobj = 0;
11054 wxRect2D *arg1 = (wxRect2D *) 0 ;
11055 wxDouble result;
11056 void *argp1 = 0 ;
11057 int res1 = 0 ;
11058 PyObject *swig_obj[1] ;
11059
11060 if (!args) SWIG_fail;
11061 swig_obj[0] = args;
11062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11065 }
11066 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11067 result = ((arg1)->m_x);
11068 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11069 return resultobj;
11070 fail:
11071 return NULL;
11072 }
11073
11074
11075 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11076 PyObject *resultobj = 0;
11077 wxRect2D *arg1 = (wxRect2D *) 0 ;
11078 wxDouble arg2 ;
11079 void *argp1 = 0 ;
11080 int res1 = 0 ;
11081 void *argp2 ;
11082 int res2 = 0 ;
11083 PyObject *swig_obj[2] ;
11084
11085 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11087 if (!SWIG_IsOK(res1)) {
11088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11089 }
11090 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11091 {
11092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11093 if (!SWIG_IsOK(res2)) {
11094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11095 }
11096 if (!argp2) {
11097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11098 } else {
11099 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11100 arg2 = *temp;
11101 if (SWIG_IsNewObj(res2)) delete temp;
11102 }
11103 }
11104 if (arg1) (arg1)->m_y = arg2;
11105
11106 resultobj = SWIG_Py_Void();
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11114 PyObject *resultobj = 0;
11115 wxRect2D *arg1 = (wxRect2D *) 0 ;
11116 wxDouble result;
11117 void *argp1 = 0 ;
11118 int res1 = 0 ;
11119 PyObject *swig_obj[1] ;
11120
11121 if (!args) SWIG_fail;
11122 swig_obj[0] = args;
11123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11124 if (!SWIG_IsOK(res1)) {
11125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11126 }
11127 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11128 result = ((arg1)->m_y);
11129 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11130 return resultobj;
11131 fail:
11132 return NULL;
11133 }
11134
11135
11136 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11137 PyObject *resultobj = 0;
11138 wxRect2D *arg1 = (wxRect2D *) 0 ;
11139 wxDouble arg2 ;
11140 void *argp1 = 0 ;
11141 int res1 = 0 ;
11142 void *argp2 ;
11143 int res2 = 0 ;
11144 PyObject *swig_obj[2] ;
11145
11146 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11148 if (!SWIG_IsOK(res1)) {
11149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11150 }
11151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11152 {
11153 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11154 if (!SWIG_IsOK(res2)) {
11155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11156 }
11157 if (!argp2) {
11158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11159 } else {
11160 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11161 arg2 = *temp;
11162 if (SWIG_IsNewObj(res2)) delete temp;
11163 }
11164 }
11165 if (arg1) (arg1)->m_width = arg2;
11166
11167 resultobj = SWIG_Py_Void();
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11175 PyObject *resultobj = 0;
11176 wxRect2D *arg1 = (wxRect2D *) 0 ;
11177 wxDouble result;
11178 void *argp1 = 0 ;
11179 int res1 = 0 ;
11180 PyObject *swig_obj[1] ;
11181
11182 if (!args) SWIG_fail;
11183 swig_obj[0] = args;
11184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11185 if (!SWIG_IsOK(res1)) {
11186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11187 }
11188 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11189 result = ((arg1)->m_width);
11190 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199 wxRect2D *arg1 = (wxRect2D *) 0 ;
11200 wxDouble arg2 ;
11201 void *argp1 = 0 ;
11202 int res1 = 0 ;
11203 void *argp2 ;
11204 int res2 = 0 ;
11205 PyObject *swig_obj[2] ;
11206
11207 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11209 if (!SWIG_IsOK(res1)) {
11210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11211 }
11212 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11213 {
11214 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11215 if (!SWIG_IsOK(res2)) {
11216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11217 }
11218 if (!argp2) {
11219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11220 } else {
11221 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11222 arg2 = *temp;
11223 if (SWIG_IsNewObj(res2)) delete temp;
11224 }
11225 }
11226 if (arg1) (arg1)->m_height = arg2;
11227
11228 resultobj = SWIG_Py_Void();
11229 return resultobj;
11230 fail:
11231 return NULL;
11232 }
11233
11234
11235 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11236 PyObject *resultobj = 0;
11237 wxRect2D *arg1 = (wxRect2D *) 0 ;
11238 wxDouble result;
11239 void *argp1 = 0 ;
11240 int res1 = 0 ;
11241 PyObject *swig_obj[1] ;
11242
11243 if (!args) SWIG_fail;
11244 swig_obj[0] = args;
11245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11246 if (!SWIG_IsOK(res1)) {
11247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11248 }
11249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11250 result = ((arg1)->m_height);
11251 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxRect2D *arg1 = (wxRect2D *) 0 ;
11261 wxDouble arg2 = (wxDouble) 0 ;
11262 wxDouble arg3 = (wxDouble) 0 ;
11263 wxDouble arg4 = (wxDouble) 0 ;
11264 wxDouble arg5 = (wxDouble) 0 ;
11265 void *argp1 = 0 ;
11266 int res1 = 0 ;
11267 void *argp2 ;
11268 int res2 = 0 ;
11269 void *argp3 ;
11270 int res3 = 0 ;
11271 void *argp4 ;
11272 int res4 = 0 ;
11273 void *argp5 ;
11274 int res5 = 0 ;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 PyObject * obj3 = 0 ;
11279 PyObject * obj4 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11286 if (!SWIG_IsOK(res1)) {
11287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11288 }
11289 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11290 if (obj1) {
11291 {
11292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11293 if (!SWIG_IsOK(res2)) {
11294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11295 }
11296 if (!argp2) {
11297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11298 } else {
11299 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11300 arg2 = *temp;
11301 if (SWIG_IsNewObj(res2)) delete temp;
11302 }
11303 }
11304 }
11305 if (obj2) {
11306 {
11307 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11308 if (!SWIG_IsOK(res3)) {
11309 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11310 }
11311 if (!argp3) {
11312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11313 } else {
11314 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11315 arg3 = *temp;
11316 if (SWIG_IsNewObj(res3)) delete temp;
11317 }
11318 }
11319 }
11320 if (obj3) {
11321 {
11322 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11323 if (!SWIG_IsOK(res4)) {
11324 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11325 }
11326 if (!argp4) {
11327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11328 } else {
11329 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11330 arg4 = *temp;
11331 if (SWIG_IsNewObj(res4)) delete temp;
11332 }
11333 }
11334 }
11335 if (obj4) {
11336 {
11337 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11338 if (!SWIG_IsOK(res5)) {
11339 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11340 }
11341 if (!argp5) {
11342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11343 } else {
11344 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11345 arg5 = *temp;
11346 if (SWIG_IsNewObj(res5)) delete temp;
11347 }
11348 }
11349 }
11350 {
11351 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 resultobj = SWIG_Py_Void();
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11362 PyObject *resultobj = 0;
11363 wxRect2D *arg1 = (wxRect2D *) 0 ;
11364 PyObject *result = 0 ;
11365 void *argp1 = 0 ;
11366 int res1 = 0 ;
11367 PyObject *swig_obj[1] ;
11368
11369 if (!args) SWIG_fail;
11370 swig_obj[0] = args;
11371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11372 if (!SWIG_IsOK(res1)) {
11373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11374 }
11375 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11376 {
11377 result = (PyObject *)wxRect2D_Get(arg1);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 resultobj = result;
11381 return resultobj;
11382 fail:
11383 return NULL;
11384 }
11385
11386
11387 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11388 PyObject *obj;
11389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11390 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11391 return SWIG_Py_Void();
11392 }
11393
11394 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11395 return SWIG_Python_InitShadowInstance(args);
11396 }
11397
11398 SWIGINTERN int DefaultPosition_set(PyObject *) {
11399 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11400 return 1;
11401 }
11402
11403
11404 SWIGINTERN PyObject *DefaultPosition_get(void) {
11405 PyObject *pyobj = 0;
11406
11407 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11408 return pyobj;
11409 }
11410
11411
11412 SWIGINTERN int DefaultSize_set(PyObject *) {
11413 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11414 return 1;
11415 }
11416
11417
11418 SWIGINTERN PyObject *DefaultSize_get(void) {
11419 PyObject *pyobj = 0;
11420
11421 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11422 return pyobj;
11423 }
11424
11425
11426 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11427 PyObject *resultobj = 0;
11428 PyObject *arg1 = (PyObject *) 0 ;
11429 wxPyInputStream *result = 0 ;
11430 PyObject * obj0 = 0 ;
11431 char * kwnames[] = {
11432 (char *) "p", NULL
11433 };
11434
11435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11436 arg1 = obj0;
11437 {
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11451 PyObject *resultobj = 0;
11452 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11453 void *argp1 = 0 ;
11454 int res1 = 0 ;
11455 PyObject *swig_obj[1] ;
11456
11457 if (!args) SWIG_fail;
11458 swig_obj[0] = args;
11459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11460 if (!SWIG_IsOK(res1)) {
11461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11462 }
11463 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11464 {
11465 PyThreadState* __tstate = wxPyBeginAllowThreads();
11466 delete arg1;
11467
11468 wxPyEndAllowThreads(__tstate);
11469 if (PyErr_Occurred()) SWIG_fail;
11470 }
11471 resultobj = SWIG_Py_Void();
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11479 PyObject *resultobj = 0;
11480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11481 void *argp1 = 0 ;
11482 int res1 = 0 ;
11483 PyObject *swig_obj[1] ;
11484
11485 if (!args) SWIG_fail;
11486 swig_obj[0] = args;
11487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11488 if (!SWIG_IsOK(res1)) {
11489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11490 }
11491 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 (arg1)->close();
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 resultobj = SWIG_Py_Void();
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11506 PyObject *resultobj = 0;
11507 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11508 void *argp1 = 0 ;
11509 int res1 = 0 ;
11510 PyObject *swig_obj[1] ;
11511
11512 if (!args) SWIG_fail;
11513 swig_obj[0] = args;
11514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11515 if (!SWIG_IsOK(res1)) {
11516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11517 }
11518 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11519 {
11520 PyThreadState* __tstate = wxPyBeginAllowThreads();
11521 (arg1)->flush();
11522 wxPyEndAllowThreads(__tstate);
11523 if (PyErr_Occurred()) SWIG_fail;
11524 }
11525 resultobj = SWIG_Py_Void();
11526 return resultobj;
11527 fail:
11528 return NULL;
11529 }
11530
11531
11532 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11533 PyObject *resultobj = 0;
11534 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11535 bool result;
11536 void *argp1 = 0 ;
11537 int res1 = 0 ;
11538 PyObject *swig_obj[1] ;
11539
11540 if (!args) SWIG_fail;
11541 swig_obj[0] = args;
11542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11543 if (!SWIG_IsOK(res1)) {
11544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11545 }
11546 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->eof();
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11563 PyObject *resultobj = 0;
11564 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11565 int arg2 = (int) -1 ;
11566 PyObject *result = 0 ;
11567 void *argp1 = 0 ;
11568 int res1 = 0 ;
11569 int val2 ;
11570 int ecode2 = 0 ;
11571 PyObject * obj0 = 0 ;
11572 PyObject * obj1 = 0 ;
11573 char * kwnames[] = {
11574 (char *) "self",(char *) "size", NULL
11575 };
11576
11577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11581 }
11582 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11583 if (obj1) {
11584 ecode2 = SWIG_AsVal_int(obj1, &val2);
11585 if (!SWIG_IsOK(ecode2)) {
11586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11587 }
11588 arg2 = static_cast< int >(val2);
11589 }
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (PyObject *)(arg1)->read(arg2);
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 resultobj = result;
11597 return resultobj;
11598 fail:
11599 return NULL;
11600 }
11601
11602
11603 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11604 PyObject *resultobj = 0;
11605 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11606 int arg2 = (int) -1 ;
11607 PyObject *result = 0 ;
11608 void *argp1 = 0 ;
11609 int res1 = 0 ;
11610 int val2 ;
11611 int ecode2 = 0 ;
11612 PyObject * obj0 = 0 ;
11613 PyObject * obj1 = 0 ;
11614 char * kwnames[] = {
11615 (char *) "self",(char *) "size", NULL
11616 };
11617
11618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11620 if (!SWIG_IsOK(res1)) {
11621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11622 }
11623 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11624 if (obj1) {
11625 ecode2 = SWIG_AsVal_int(obj1, &val2);
11626 if (!SWIG_IsOK(ecode2)) {
11627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11628 }
11629 arg2 = static_cast< int >(val2);
11630 }
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (PyObject *)(arg1)->readline(arg2);
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 resultobj = result;
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj = 0;
11646 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11647 int arg2 = (int) -1 ;
11648 PyObject *result = 0 ;
11649 void *argp1 = 0 ;
11650 int res1 = 0 ;
11651 int val2 ;
11652 int ecode2 = 0 ;
11653 PyObject * obj0 = 0 ;
11654 PyObject * obj1 = 0 ;
11655 char * kwnames[] = {
11656 (char *) "self",(char *) "sizehint", NULL
11657 };
11658
11659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11665 if (obj1) {
11666 ecode2 = SWIG_AsVal_int(obj1, &val2);
11667 if (!SWIG_IsOK(ecode2)) {
11668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11669 }
11670 arg2 = static_cast< int >(val2);
11671 }
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (PyObject *)(arg1)->readlines(arg2);
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 resultobj = result;
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11686 PyObject *resultobj = 0;
11687 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11688 int arg2 ;
11689 int arg3 = (int) 0 ;
11690 void *argp1 = 0 ;
11691 int res1 = 0 ;
11692 int val2 ;
11693 int ecode2 = 0 ;
11694 int val3 ;
11695 int ecode3 = 0 ;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11698 PyObject * obj2 = 0 ;
11699 char * kwnames[] = {
11700 (char *) "self",(char *) "offset",(char *) "whence", NULL
11701 };
11702
11703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11707 }
11708 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11709 ecode2 = SWIG_AsVal_int(obj1, &val2);
11710 if (!SWIG_IsOK(ecode2)) {
11711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11712 }
11713 arg2 = static_cast< int >(val2);
11714 if (obj2) {
11715 ecode3 = SWIG_AsVal_int(obj2, &val3);
11716 if (!SWIG_IsOK(ecode3)) {
11717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11718 }
11719 arg3 = static_cast< int >(val3);
11720 }
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 (arg1)->seek(arg2,arg3);
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 resultobj = SWIG_Py_Void();
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11737 int result;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11747 }
11748 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (int)(arg1)->tell();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_From_int(static_cast< int >(result));
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11765 char result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11775 }
11776 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (char)(arg1)->Peek();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_From_char(static_cast< char >(result));
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11793 char result;
11794 void *argp1 = 0 ;
11795 int res1 = 0 ;
11796 PyObject *swig_obj[1] ;
11797
11798 if (!args) SWIG_fail;
11799 swig_obj[0] = args;
11800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11801 if (!SWIG_IsOK(res1)) {
11802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11803 }
11804 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (char)(arg1)->GetC();
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_From_char(static_cast< char >(result));
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11821 size_t result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11831 }
11832 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (size_t)(arg1)->LastRead();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11847 PyObject *resultobj = 0;
11848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11849 bool result;
11850 void *argp1 = 0 ;
11851 int res1 = 0 ;
11852 PyObject *swig_obj[1] ;
11853
11854 if (!args) SWIG_fail;
11855 swig_obj[0] = args;
11856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11859 }
11860 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (bool)(arg1)->CanRead();
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11877 PyObject *resultobj = 0;
11878 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11879 bool result;
11880 void *argp1 = 0 ;
11881 int res1 = 0 ;
11882 PyObject *swig_obj[1] ;
11883
11884 if (!args) SWIG_fail;
11885 swig_obj[0] = args;
11886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11887 if (!SWIG_IsOK(res1)) {
11888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11889 }
11890 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11891 {
11892 PyThreadState* __tstate = wxPyBeginAllowThreads();
11893 result = (bool)(arg1)->Eof();
11894 wxPyEndAllowThreads(__tstate);
11895 if (PyErr_Occurred()) SWIG_fail;
11896 }
11897 {
11898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11899 }
11900 return resultobj;
11901 fail:
11902 return NULL;
11903 }
11904
11905
11906 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj = 0;
11908 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11909 char arg2 ;
11910 bool result;
11911 void *argp1 = 0 ;
11912 int res1 = 0 ;
11913 char val2 ;
11914 int ecode2 = 0 ;
11915 PyObject * obj0 = 0 ;
11916 PyObject * obj1 = 0 ;
11917 char * kwnames[] = {
11918 (char *) "self",(char *) "c", NULL
11919 };
11920
11921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11923 if (!SWIG_IsOK(res1)) {
11924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11925 }
11926 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11927 ecode2 = SWIG_AsVal_char(obj1, &val2);
11928 if (!SWIG_IsOK(ecode2)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11930 }
11931 arg2 = static_cast< char >(val2);
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)(arg1)->Ungetch(arg2);
11935 wxPyEndAllowThreads(__tstate);
11936 if (PyErr_Occurred()) SWIG_fail;
11937 }
11938 {
11939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11940 }
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = 0;
11949 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11950 long arg2 ;
11951 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11952 long result;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955 long val2 ;
11956 int ecode2 = 0 ;
11957 int val3 ;
11958 int ecode3 = 0 ;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 PyObject * obj2 = 0 ;
11962 char * kwnames[] = {
11963 (char *) "self",(char *) "pos",(char *) "mode", NULL
11964 };
11965
11966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11968 if (!SWIG_IsOK(res1)) {
11969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11970 }
11971 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11972 ecode2 = SWIG_AsVal_long(obj1, &val2);
11973 if (!SWIG_IsOK(ecode2)) {
11974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11975 }
11976 arg2 = static_cast< long >(val2);
11977 if (obj2) {
11978 ecode3 = SWIG_AsVal_int(obj2, &val3);
11979 if (!SWIG_IsOK(ecode3)) {
11980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11981 }
11982 arg3 = static_cast< wxSeekMode >(val3);
11983 }
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (long)(arg1)->SeekI(arg2,arg3);
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 resultobj = SWIG_From_long(static_cast< long >(result));
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11998 PyObject *resultobj = 0;
11999 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12000 long result;
12001 void *argp1 = 0 ;
12002 int res1 = 0 ;
12003 PyObject *swig_obj[1] ;
12004
12005 if (!args) SWIG_fail;
12006 swig_obj[0] = args;
12007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12008 if (!SWIG_IsOK(res1)) {
12009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12010 }
12011 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (long)(arg1)->TellI();
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 resultobj = SWIG_From_long(static_cast< long >(result));
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12026 PyObject *obj;
12027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12028 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12029 return SWIG_Py_Void();
12030 }
12031
12032 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 return SWIG_Python_InitShadowInstance(args);
12034 }
12035
12036 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12037 PyObject *resultobj = 0;
12038 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12039 PyObject *arg2 = (PyObject *) 0 ;
12040 void *argp1 = 0 ;
12041 int res1 = 0 ;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 char * kwnames[] = {
12045 (char *) "self",(char *) "obj", NULL
12046 };
12047
12048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12050 if (!SWIG_IsOK(res1)) {
12051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12052 }
12053 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12054 arg2 = obj1;
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 wxOutputStream_write(arg1,arg2);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_Py_Void();
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12069 PyObject *resultobj = 0;
12070 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12071 size_t result;
12072 void *argp1 = 0 ;
12073 int res1 = 0 ;
12074 PyObject *swig_obj[1] ;
12075
12076 if (!args) SWIG_fail;
12077 swig_obj[0] = args;
12078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12081 }
12082 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12086 wxPyEndAllowThreads(__tstate);
12087 if (PyErr_Occurred()) SWIG_fail;
12088 }
12089 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12097 PyObject *obj;
12098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12099 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12100 return SWIG_Py_Void();
12101 }
12102
12103 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj = 0;
12105 wxInputStream *arg1 = (wxInputStream *) 0 ;
12106 wxString *arg2 = 0 ;
12107 wxString *arg3 = 0 ;
12108 wxString *arg4 = 0 ;
12109 wxDateTime arg5 ;
12110 wxFSFile *result = 0 ;
12111 wxPyInputStream *temp1 ;
12112 bool temp2 = false ;
12113 bool temp3 = false ;
12114 bool temp4 = false ;
12115 void *argp5 ;
12116 int res5 = 0 ;
12117 PyObject * obj0 = 0 ;
12118 PyObject * obj1 = 0 ;
12119 PyObject * obj2 = 0 ;
12120 PyObject * obj3 = 0 ;
12121 PyObject * obj4 = 0 ;
12122 char * kwnames[] = {
12123 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12124 };
12125
12126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12127 {
12128 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12129 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12130 } else {
12131 PyErr_Clear(); // clear the failure of the wxPyConvert above
12132 arg1 = wxPyCBInputStream_create(obj0, true);
12133 if (arg1 == NULL) {
12134 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12135 SWIG_fail;
12136 }
12137 }
12138 }
12139 {
12140 arg2 = wxString_in_helper(obj1);
12141 if (arg2 == NULL) SWIG_fail;
12142 temp2 = true;
12143 }
12144 {
12145 arg3 = wxString_in_helper(obj2);
12146 if (arg3 == NULL) SWIG_fail;
12147 temp3 = true;
12148 }
12149 {
12150 arg4 = wxString_in_helper(obj3);
12151 if (arg4 == NULL) SWIG_fail;
12152 temp4 = true;
12153 }
12154 {
12155 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12156 if (!SWIG_IsOK(res5)) {
12157 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12158 }
12159 if (!argp5) {
12160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12161 } else {
12162 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12163 arg5 = *temp;
12164 if (SWIG_IsNewObj(res5)) delete temp;
12165 }
12166 }
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12174 {
12175 if (temp2)
12176 delete arg2;
12177 }
12178 {
12179 if (temp3)
12180 delete arg3;
12181 }
12182 {
12183 if (temp4)
12184 delete arg4;
12185 }
12186 return resultobj;
12187 fail:
12188 {
12189 if (temp2)
12190 delete arg2;
12191 }
12192 {
12193 if (temp3)
12194 delete arg3;
12195 }
12196 {
12197 if (temp4)
12198 delete arg4;
12199 }
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12205 PyObject *resultobj = 0;
12206 wxFSFile *arg1 = (wxFSFile *) 0 ;
12207 void *argp1 = 0 ;
12208 int res1 = 0 ;
12209 PyObject *swig_obj[1] ;
12210
12211 if (!args) SWIG_fail;
12212 swig_obj[0] = args;
12213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12214 if (!SWIG_IsOK(res1)) {
12215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12216 }
12217 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 delete arg1;
12221
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_Py_Void();
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12233 PyObject *resultobj = 0;
12234 wxFSFile *arg1 = (wxFSFile *) 0 ;
12235 wxInputStream *result = 0 ;
12236 void *argp1 = 0 ;
12237 int res1 = 0 ;
12238 PyObject *swig_obj[1] ;
12239
12240 if (!args) SWIG_fail;
12241 swig_obj[0] = args;
12242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12245 }
12246 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (wxInputStream *)(arg1)->GetStream();
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 {
12254 wxPyInputStream * _ptr = NULL;
12255
12256 if (result) {
12257 _ptr = new wxPyInputStream(result);
12258 }
12259 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12268 PyObject *resultobj = 0;
12269 wxFSFile *arg1 = (wxFSFile *) 0 ;
12270 void *argp1 = 0 ;
12271 int res1 = 0 ;
12272 PyObject *swig_obj[1] ;
12273
12274 if (!args) SWIG_fail;
12275 swig_obj[0] = args;
12276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12277 if (!SWIG_IsOK(res1)) {
12278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12279 }
12280 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 (arg1)->DetachStream();
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 resultobj = SWIG_Py_Void();
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12295 PyObject *resultobj = 0;
12296 wxFSFile *arg1 = (wxFSFile *) 0 ;
12297 wxString *result = 0 ;
12298 void *argp1 = 0 ;
12299 int res1 = 0 ;
12300 PyObject *swig_obj[1] ;
12301
12302 if (!args) SWIG_fail;
12303 swig_obj[0] = args;
12304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12305 if (!SWIG_IsOK(res1)) {
12306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12307 }
12308 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 {
12312 wxString const &_result_ref = (arg1)->GetMimeType();
12313 result = (wxString *) &_result_ref;
12314 }
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 {
12319 #if wxUSE_UNICODE
12320 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12321 #else
12322 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12323 #endif
12324 }
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12332 PyObject *resultobj = 0;
12333 wxFSFile *arg1 = (wxFSFile *) 0 ;
12334 wxString *result = 0 ;
12335 void *argp1 = 0 ;
12336 int res1 = 0 ;
12337 PyObject *swig_obj[1] ;
12338
12339 if (!args) SWIG_fail;
12340 swig_obj[0] = args;
12341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12342 if (!SWIG_IsOK(res1)) {
12343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12344 }
12345 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 {
12349 wxString const &_result_ref = (arg1)->GetLocation();
12350 result = (wxString *) &_result_ref;
12351 }
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 {
12356 #if wxUSE_UNICODE
12357 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12358 #else
12359 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12360 #endif
12361 }
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12369 PyObject *resultobj = 0;
12370 wxFSFile *arg1 = (wxFSFile *) 0 ;
12371 wxString *result = 0 ;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 PyObject *swig_obj[1] ;
12375
12376 if (!args) SWIG_fail;
12377 swig_obj[0] = args;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12381 }
12382 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 {
12386 wxString const &_result_ref = (arg1)->GetAnchor();
12387 result = (wxString *) &_result_ref;
12388 }
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 #if wxUSE_UNICODE
12394 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12395 #else
12396 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12397 #endif
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406 PyObject *resultobj = 0;
12407 wxFSFile *arg1 = (wxFSFile *) 0 ;
12408 wxDateTime result;
12409 void *argp1 = 0 ;
12410 int res1 = 0 ;
12411 PyObject *swig_obj[1] ;
12412
12413 if (!args) SWIG_fail;
12414 swig_obj[0] = args;
12415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12416 if (!SWIG_IsOK(res1)) {
12417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12418 }
12419 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 result = (arg1)->GetModificationTime();
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12434 PyObject *obj;
12435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12436 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12437 return SWIG_Py_Void();
12438 }
12439
12440 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12441 return SWIG_Python_InitShadowInstance(args);
12442 }
12443
12444 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 PyObject *resultobj = 0;
12446 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12447 void *argp1 = 0 ;
12448 int res1 = 0 ;
12449 PyObject *swig_obj[1] ;
12450
12451 if (!args) SWIG_fail;
12452 swig_obj[0] = args;
12453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12456 }
12457 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 delete arg1;
12461
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_Py_Void();
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12473 PyObject *obj;
12474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12475 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12476 return SWIG_Py_Void();
12477 }
12478
12479 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12480 PyObject *resultobj = 0;
12481 wxPyFileSystemHandler *result = 0 ;
12482
12483 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12484 {
12485 PyThreadState* __tstate = wxPyBeginAllowThreads();
12486 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12487 wxPyEndAllowThreads(__tstate);
12488 if (PyErr_Occurred()) SWIG_fail;
12489 }
12490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj = 0;
12499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12500 PyObject *arg2 = (PyObject *) 0 ;
12501 PyObject *arg3 = (PyObject *) 0 ;
12502 void *argp1 = 0 ;
12503 int res1 = 0 ;
12504 PyObject * obj0 = 0 ;
12505 PyObject * obj1 = 0 ;
12506 PyObject * obj2 = 0 ;
12507 char * kwnames[] = {
12508 (char *) "self",(char *) "self",(char *) "_class", NULL
12509 };
12510
12511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12515 }
12516 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12517 arg2 = obj1;
12518 arg3 = obj2;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 (arg1)->_setCallbackInfo(arg2,arg3);
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 resultobj = SWIG_Py_Void();
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj = 0;
12534 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12535 wxString *arg2 = 0 ;
12536 bool result;
12537 void *argp1 = 0 ;
12538 int res1 = 0 ;
12539 bool temp2 = false ;
12540 PyObject * obj0 = 0 ;
12541 PyObject * obj1 = 0 ;
12542 char * kwnames[] = {
12543 (char *) "self",(char *) "location", NULL
12544 };
12545
12546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12548 if (!SWIG_IsOK(res1)) {
12549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12550 }
12551 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12552 {
12553 arg2 = wxString_in_helper(obj1);
12554 if (arg2 == NULL) SWIG_fail;
12555 temp2 = true;
12556 }
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12565 }
12566 {
12567 if (temp2)
12568 delete arg2;
12569 }
12570 return resultobj;
12571 fail:
12572 {
12573 if (temp2)
12574 delete arg2;
12575 }
12576 return NULL;
12577 }
12578
12579
12580 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj = 0;
12582 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12583 wxFileSystem *arg2 = 0 ;
12584 wxString *arg3 = 0 ;
12585 wxFSFile *result = 0 ;
12586 void *argp1 = 0 ;
12587 int res1 = 0 ;
12588 void *argp2 = 0 ;
12589 int res2 = 0 ;
12590 bool temp3 = false ;
12591 PyObject * obj0 = 0 ;
12592 PyObject * obj1 = 0 ;
12593 PyObject * obj2 = 0 ;
12594 char * kwnames[] = {
12595 (char *) "self",(char *) "fs",(char *) "location", NULL
12596 };
12597
12598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12600 if (!SWIG_IsOK(res1)) {
12601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12602 }
12603 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12605 if (!SWIG_IsOK(res2)) {
12606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12607 }
12608 if (!argp2) {
12609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12610 }
12611 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12612 {
12613 arg3 = wxString_in_helper(obj2);
12614 if (arg3 == NULL) SWIG_fail;
12615 temp3 = true;
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 {
12624 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12625 }
12626 {
12627 if (temp3)
12628 delete arg3;
12629 }
12630 return resultobj;
12631 fail:
12632 {
12633 if (temp3)
12634 delete arg3;
12635 }
12636 return NULL;
12637 }
12638
12639
12640 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12641 PyObject *resultobj = 0;
12642 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12643 wxString *arg2 = 0 ;
12644 int arg3 = (int) 0 ;
12645 wxString result;
12646 void *argp1 = 0 ;
12647 int res1 = 0 ;
12648 bool temp2 = false ;
12649 int val3 ;
12650 int ecode3 = 0 ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 PyObject * obj2 = 0 ;
12654 char * kwnames[] = {
12655 (char *) "self",(char *) "spec",(char *) "flags", NULL
12656 };
12657
12658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12660 if (!SWIG_IsOK(res1)) {
12661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12662 }
12663 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12664 {
12665 arg2 = wxString_in_helper(obj1);
12666 if (arg2 == NULL) SWIG_fail;
12667 temp2 = true;
12668 }
12669 if (obj2) {
12670 ecode3 = SWIG_AsVal_int(obj2, &val3);
12671 if (!SWIG_IsOK(ecode3)) {
12672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12673 }
12674 arg3 = static_cast< int >(val3);
12675 }
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 {
12683 #if wxUSE_UNICODE
12684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12685 #else
12686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12687 #endif
12688 }
12689 {
12690 if (temp2)
12691 delete arg2;
12692 }
12693 return resultobj;
12694 fail:
12695 {
12696 if (temp2)
12697 delete arg2;
12698 }
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 PyObject *resultobj = 0;
12705 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12706 wxString result;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 PyObject *swig_obj[1] ;
12710
12711 if (!args) SWIG_fail;
12712 swig_obj[0] = args;
12713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12714 if (!SWIG_IsOK(res1)) {
12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12716 }
12717 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (arg1)->FindNext();
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 {
12725 #if wxUSE_UNICODE
12726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12727 #else
12728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12729 #endif
12730 }
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12738 PyObject *resultobj = 0;
12739 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12740 wxString *arg2 = 0 ;
12741 wxString result;
12742 void *argp1 = 0 ;
12743 int res1 = 0 ;
12744 bool temp2 = false ;
12745 PyObject * obj0 = 0 ;
12746 PyObject * obj1 = 0 ;
12747 char * kwnames[] = {
12748 (char *) "self",(char *) "location", NULL
12749 };
12750
12751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12755 }
12756 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12757 {
12758 arg2 = wxString_in_helper(obj1);
12759 if (arg2 == NULL) SWIG_fail;
12760 temp2 = true;
12761 }
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 result = (arg1)->GetProtocol((wxString const &)*arg2);
12765 wxPyEndAllowThreads(__tstate);
12766 if (PyErr_Occurred()) SWIG_fail;
12767 }
12768 {
12769 #if wxUSE_UNICODE
12770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12771 #else
12772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12773 #endif
12774 }
12775 {
12776 if (temp2)
12777 delete arg2;
12778 }
12779 return resultobj;
12780 fail:
12781 {
12782 if (temp2)
12783 delete arg2;
12784 }
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj = 0;
12791 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12792 wxString *arg2 = 0 ;
12793 wxString result;
12794 void *argp1 = 0 ;
12795 int res1 = 0 ;
12796 bool temp2 = false ;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 char * kwnames[] = {
12800 (char *) "self",(char *) "location", NULL
12801 };
12802
12803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12805 if (!SWIG_IsOK(res1)) {
12806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12807 }
12808 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12809 {
12810 arg2 = wxString_in_helper(obj1);
12811 if (arg2 == NULL) SWIG_fail;
12812 temp2 = true;
12813 }
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12817 wxPyEndAllowThreads(__tstate);
12818 if (PyErr_Occurred()) SWIG_fail;
12819 }
12820 {
12821 #if wxUSE_UNICODE
12822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12823 #else
12824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12825 #endif
12826 }
12827 {
12828 if (temp2)
12829 delete arg2;
12830 }
12831 return resultobj;
12832 fail:
12833 {
12834 if (temp2)
12835 delete arg2;
12836 }
12837 return NULL;
12838 }
12839
12840
12841 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj = 0;
12843 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12844 wxString *arg2 = 0 ;
12845 wxString result;
12846 void *argp1 = 0 ;
12847 int res1 = 0 ;
12848 bool temp2 = false ;
12849 PyObject * obj0 = 0 ;
12850 PyObject * obj1 = 0 ;
12851 char * kwnames[] = {
12852 (char *) "self",(char *) "location", NULL
12853 };
12854
12855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12857 if (!SWIG_IsOK(res1)) {
12858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12859 }
12860 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12861 {
12862 arg2 = wxString_in_helper(obj1);
12863 if (arg2 == NULL) SWIG_fail;
12864 temp2 = true;
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 result = (arg1)->GetAnchor((wxString const &)*arg2);
12869 wxPyEndAllowThreads(__tstate);
12870 if (PyErr_Occurred()) SWIG_fail;
12871 }
12872 {
12873 #if wxUSE_UNICODE
12874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12875 #else
12876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12877 #endif
12878 }
12879 {
12880 if (temp2)
12881 delete arg2;
12882 }
12883 return resultobj;
12884 fail:
12885 {
12886 if (temp2)
12887 delete arg2;
12888 }
12889 return NULL;
12890 }
12891
12892
12893 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12894 PyObject *resultobj = 0;
12895 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12896 wxString *arg2 = 0 ;
12897 wxString result;
12898 void *argp1 = 0 ;
12899 int res1 = 0 ;
12900 bool temp2 = false ;
12901 PyObject * obj0 = 0 ;
12902 PyObject * obj1 = 0 ;
12903 char * kwnames[] = {
12904 (char *) "self",(char *) "location", NULL
12905 };
12906
12907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12909 if (!SWIG_IsOK(res1)) {
12910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12911 }
12912 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12913 {
12914 arg2 = wxString_in_helper(obj1);
12915 if (arg2 == NULL) SWIG_fail;
12916 temp2 = true;
12917 }
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 {
12925 #if wxUSE_UNICODE
12926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12927 #else
12928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12929 #endif
12930 }
12931 {
12932 if (temp2)
12933 delete arg2;
12934 }
12935 return resultobj;
12936 fail:
12937 {
12938 if (temp2)
12939 delete arg2;
12940 }
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj = 0;
12947 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12948 wxString *arg2 = 0 ;
12949 wxString result;
12950 void *argp1 = 0 ;
12951 int res1 = 0 ;
12952 bool temp2 = false ;
12953 PyObject * obj0 = 0 ;
12954 PyObject * obj1 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "self",(char *) "location", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12963 }
12964 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12965 {
12966 arg2 = wxString_in_helper(obj1);
12967 if (arg2 == NULL) SWIG_fail;
12968 temp2 = true;
12969 }
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 {
12977 #if wxUSE_UNICODE
12978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12979 #else
12980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12981 #endif
12982 }
12983 {
12984 if (temp2)
12985 delete arg2;
12986 }
12987 return resultobj;
12988 fail:
12989 {
12990 if (temp2)
12991 delete arg2;
12992 }
12993 return NULL;
12994 }
12995
12996
12997 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12998 PyObject *obj;
12999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13001 return SWIG_Py_Void();
13002 }
13003
13004 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13005 return SWIG_Python_InitShadowInstance(args);
13006 }
13007
13008 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13009 PyObject *resultobj = 0;
13010 wxFileSystem *result = 0 ;
13011
13012 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 result = (wxFileSystem *)new wxFileSystem();
13016 wxPyEndAllowThreads(__tstate);
13017 if (PyErr_Occurred()) SWIG_fail;
13018 }
13019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13020 return resultobj;
13021 fail:
13022 return NULL;
13023 }
13024
13025
13026 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13027 PyObject *resultobj = 0;
13028 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 PyObject *swig_obj[1] ;
13032
13033 if (!args) SWIG_fail;
13034 swig_obj[0] = args;
13035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13038 }
13039 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 delete arg1;
13043
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 resultobj = SWIG_Py_Void();
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13057 wxString *arg2 = 0 ;
13058 bool arg3 = (bool) false ;
13059 void *argp1 = 0 ;
13060 int res1 = 0 ;
13061 bool temp2 = false ;
13062 bool val3 ;
13063 int ecode3 = 0 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 PyObject * obj2 = 0 ;
13067 char * kwnames[] = {
13068 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13069 };
13070
13071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13073 if (!SWIG_IsOK(res1)) {
13074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13075 }
13076 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13077 {
13078 arg2 = wxString_in_helper(obj1);
13079 if (arg2 == NULL) SWIG_fail;
13080 temp2 = true;
13081 }
13082 if (obj2) {
13083 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13084 if (!SWIG_IsOK(ecode3)) {
13085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13086 }
13087 arg3 = static_cast< bool >(val3);
13088 }
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 resultobj = SWIG_Py_Void();
13096 {
13097 if (temp2)
13098 delete arg2;
13099 }
13100 return resultobj;
13101 fail:
13102 {
13103 if (temp2)
13104 delete arg2;
13105 }
13106 return NULL;
13107 }
13108
13109
13110 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13111 PyObject *resultobj = 0;
13112 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13113 wxString result;
13114 void *argp1 = 0 ;
13115 int res1 = 0 ;
13116 PyObject *swig_obj[1] ;
13117
13118 if (!args) SWIG_fail;
13119 swig_obj[0] = args;
13120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13121 if (!SWIG_IsOK(res1)) {
13122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13123 }
13124 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 result = (arg1)->GetPath();
13128 wxPyEndAllowThreads(__tstate);
13129 if (PyErr_Occurred()) SWIG_fail;
13130 }
13131 {
13132 #if wxUSE_UNICODE
13133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13134 #else
13135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13136 #endif
13137 }
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13147 wxString *arg2 = 0 ;
13148 wxFSFile *result = 0 ;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 bool temp2 = false ;
13152 PyObject * obj0 = 0 ;
13153 PyObject * obj1 = 0 ;
13154 char * kwnames[] = {
13155 (char *) "self",(char *) "location", NULL
13156 };
13157
13158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13162 }
13163 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13164 {
13165 arg2 = wxString_in_helper(obj1);
13166 if (arg2 == NULL) SWIG_fail;
13167 temp2 = true;
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 {
13176 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13177 }
13178 {
13179 if (temp2)
13180 delete arg2;
13181 }
13182 return resultobj;
13183 fail:
13184 {
13185 if (temp2)
13186 delete arg2;
13187 }
13188 return NULL;
13189 }
13190
13191
13192 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj = 0;
13194 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13195 wxString *arg2 = 0 ;
13196 int arg3 = (int) 0 ;
13197 wxString result;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 bool temp2 = false ;
13201 int val3 ;
13202 int ecode3 = 0 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 PyObject * obj2 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "self",(char *) "spec",(char *) "flags", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13214 }
13215 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13216 {
13217 arg2 = wxString_in_helper(obj1);
13218 if (arg2 == NULL) SWIG_fail;
13219 temp2 = true;
13220 }
13221 if (obj2) {
13222 ecode3 = SWIG_AsVal_int(obj2, &val3);
13223 if (!SWIG_IsOK(ecode3)) {
13224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13225 }
13226 arg3 = static_cast< int >(val3);
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 #if wxUSE_UNICODE
13236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13237 #else
13238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13239 #endif
13240 }
13241 {
13242 if (temp2)
13243 delete arg2;
13244 }
13245 return resultobj;
13246 fail:
13247 {
13248 if (temp2)
13249 delete arg2;
13250 }
13251 return NULL;
13252 }
13253
13254
13255 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13256 PyObject *resultobj = 0;
13257 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13258 wxString result;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 PyObject *swig_obj[1] ;
13262
13263 if (!args) SWIG_fail;
13264 swig_obj[0] = args;
13265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13266 if (!SWIG_IsOK(res1)) {
13267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13268 }
13269 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 result = (arg1)->FindNext();
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 {
13277 #if wxUSE_UNICODE
13278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13279 #else
13280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13281 #endif
13282 }
13283 return resultobj;
13284 fail:
13285 return NULL;
13286 }
13287
13288
13289 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13290 PyObject *resultobj = 0;
13291 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13292 int res1 = 0 ;
13293 PyObject * obj0 = 0 ;
13294 char * kwnames[] = {
13295 (char *) "handler", NULL
13296 };
13297
13298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13299 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13300 if (!SWIG_IsOK(res1)) {
13301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13302 }
13303 {
13304 PyThreadState* __tstate = wxPyBeginAllowThreads();
13305 wxFileSystem::AddHandler(arg1);
13306 wxPyEndAllowThreads(__tstate);
13307 if (PyErr_Occurred()) SWIG_fail;
13308 }
13309 resultobj = SWIG_Py_Void();
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj = 0;
13318 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13319 wxFileSystemHandler *result = 0 ;
13320 void *argp1 = 0 ;
13321 int res1 = 0 ;
13322 PyObject * obj0 = 0 ;
13323 char * kwnames[] = {
13324 (char *) "handler", NULL
13325 };
13326
13327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13329 if (!SWIG_IsOK(res1)) {
13330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13331 }
13332 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13340 return resultobj;
13341 fail:
13342 return NULL;
13343 }
13344
13345
13346 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13347 PyObject *resultobj = 0;
13348
13349 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13350 {
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 wxFileSystem::CleanUpHandlers();
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 resultobj = SWIG_Py_Void();
13357 return resultobj;
13358 fail:
13359 return NULL;
13360 }
13361
13362
13363 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13364 PyObject *resultobj = 0;
13365 wxString *arg1 = 0 ;
13366 wxString result;
13367 bool temp1 = false ;
13368 PyObject * obj0 = 0 ;
13369 char * kwnames[] = {
13370 (char *) "filename", NULL
13371 };
13372
13373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13374 {
13375 arg1 = wxString_in_helper(obj0);
13376 if (arg1 == NULL) SWIG_fail;
13377 temp1 = true;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 {
13386 #if wxUSE_UNICODE
13387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13388 #else
13389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13390 #endif
13391 }
13392 {
13393 if (temp1)
13394 delete arg1;
13395 }
13396 return resultobj;
13397 fail:
13398 {
13399 if (temp1)
13400 delete arg1;
13401 }
13402 return NULL;
13403 }
13404
13405
13406 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj = 0;
13408 wxString *arg1 = 0 ;
13409 wxString result;
13410 bool temp1 = false ;
13411 PyObject * obj0 = 0 ;
13412 char * kwnames[] = {
13413 (char *) "url", NULL
13414 };
13415
13416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13417 {
13418 arg1 = wxString_in_helper(obj0);
13419 if (arg1 == NULL) SWIG_fail;
13420 temp1 = true;
13421 }
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 {
13429 #if wxUSE_UNICODE
13430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13431 #else
13432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13433 #endif
13434 }
13435 {
13436 if (temp1)
13437 delete arg1;
13438 }
13439 return resultobj;
13440 fail:
13441 {
13442 if (temp1)
13443 delete arg1;
13444 }
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13450 PyObject *obj;
13451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13452 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13453 return SWIG_Py_Void();
13454 }
13455
13456 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13457 return SWIG_Python_InitShadowInstance(args);
13458 }
13459
13460 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13461 PyObject *resultobj = 0;
13462 wxInternetFSHandler *result = 0 ;
13463
13464 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13465 {
13466 PyThreadState* __tstate = wxPyBeginAllowThreads();
13467 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13472 return resultobj;
13473 fail:
13474 return NULL;
13475 }
13476
13477
13478 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13479 PyObject *resultobj = 0;
13480 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13481 wxString *arg2 = 0 ;
13482 bool result;
13483 void *argp1 = 0 ;
13484 int res1 = 0 ;
13485 bool temp2 = false ;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 char * kwnames[] = {
13489 (char *) "self",(char *) "location", NULL
13490 };
13491
13492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13494 if (!SWIG_IsOK(res1)) {
13495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13496 }
13497 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13498 {
13499 arg2 = wxString_in_helper(obj1);
13500 if (arg2 == NULL) SWIG_fail;
13501 temp2 = true;
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 {
13510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13511 }
13512 {
13513 if (temp2)
13514 delete arg2;
13515 }
13516 return resultobj;
13517 fail:
13518 {
13519 if (temp2)
13520 delete arg2;
13521 }
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj = 0;
13528 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13529 wxFileSystem *arg2 = 0 ;
13530 wxString *arg3 = 0 ;
13531 wxFSFile *result = 0 ;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 void *argp2 = 0 ;
13535 int res2 = 0 ;
13536 bool temp3 = false ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "fs",(char *) "location", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13548 }
13549 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13551 if (!SWIG_IsOK(res2)) {
13552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13553 }
13554 if (!argp2) {
13555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13556 }
13557 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13558 {
13559 arg3 = wxString_in_helper(obj2);
13560 if (arg3 == NULL) SWIG_fail;
13561 temp3 = true;
13562 }
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 {
13570 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13571 }
13572 {
13573 if (temp3)
13574 delete arg3;
13575 }
13576 return resultobj;
13577 fail:
13578 {
13579 if (temp3)
13580 delete arg3;
13581 }
13582 return NULL;
13583 }
13584
13585
13586 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13587 PyObject *obj;
13588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13589 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13590 return SWIG_Py_Void();
13591 }
13592
13593 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 return SWIG_Python_InitShadowInstance(args);
13595 }
13596
13597 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13598 PyObject *resultobj = 0;
13599 wxZipFSHandler *result = 0 ;
13600
13601 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13602 {
13603 PyThreadState* __tstate = wxPyBeginAllowThreads();
13604 result = (wxZipFSHandler *)new wxZipFSHandler();
13605 wxPyEndAllowThreads(__tstate);
13606 if (PyErr_Occurred()) SWIG_fail;
13607 }
13608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13609 return resultobj;
13610 fail:
13611 return NULL;
13612 }
13613
13614
13615 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13616 PyObject *resultobj = 0;
13617 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13618 wxString *arg2 = 0 ;
13619 bool result;
13620 void *argp1 = 0 ;
13621 int res1 = 0 ;
13622 bool temp2 = false ;
13623 PyObject * obj0 = 0 ;
13624 PyObject * obj1 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "self",(char *) "location", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13633 }
13634 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13635 {
13636 arg2 = wxString_in_helper(obj1);
13637 if (arg2 == NULL) SWIG_fail;
13638 temp2 = true;
13639 }
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 {
13647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13648 }
13649 {
13650 if (temp2)
13651 delete arg2;
13652 }
13653 return resultobj;
13654 fail:
13655 {
13656 if (temp2)
13657 delete arg2;
13658 }
13659 return NULL;
13660 }
13661
13662
13663 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13664 PyObject *resultobj = 0;
13665 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13666 wxFileSystem *arg2 = 0 ;
13667 wxString *arg3 = 0 ;
13668 wxFSFile *result = 0 ;
13669 void *argp1 = 0 ;
13670 int res1 = 0 ;
13671 void *argp2 = 0 ;
13672 int res2 = 0 ;
13673 bool temp3 = false ;
13674 PyObject * obj0 = 0 ;
13675 PyObject * obj1 = 0 ;
13676 PyObject * obj2 = 0 ;
13677 char * kwnames[] = {
13678 (char *) "self",(char *) "fs",(char *) "location", NULL
13679 };
13680
13681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13683 if (!SWIG_IsOK(res1)) {
13684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13685 }
13686 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13688 if (!SWIG_IsOK(res2)) {
13689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13690 }
13691 if (!argp2) {
13692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13693 }
13694 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13695 {
13696 arg3 = wxString_in_helper(obj2);
13697 if (arg3 == NULL) SWIG_fail;
13698 temp3 = true;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 {
13707 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13708 }
13709 {
13710 if (temp3)
13711 delete arg3;
13712 }
13713 return resultobj;
13714 fail:
13715 {
13716 if (temp3)
13717 delete arg3;
13718 }
13719 return NULL;
13720 }
13721
13722
13723 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13724 PyObject *resultobj = 0;
13725 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13726 wxString *arg2 = 0 ;
13727 int arg3 = (int) 0 ;
13728 wxString result;
13729 void *argp1 = 0 ;
13730 int res1 = 0 ;
13731 bool temp2 = false ;
13732 int val3 ;
13733 int ecode3 = 0 ;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 PyObject * obj2 = 0 ;
13737 char * kwnames[] = {
13738 (char *) "self",(char *) "spec",(char *) "flags", NULL
13739 };
13740
13741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13743 if (!SWIG_IsOK(res1)) {
13744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13745 }
13746 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13747 {
13748 arg2 = wxString_in_helper(obj1);
13749 if (arg2 == NULL) SWIG_fail;
13750 temp2 = true;
13751 }
13752 if (obj2) {
13753 ecode3 = SWIG_AsVal_int(obj2, &val3);
13754 if (!SWIG_IsOK(ecode3)) {
13755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13756 }
13757 arg3 = static_cast< int >(val3);
13758 }
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 {
13766 #if wxUSE_UNICODE
13767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13768 #else
13769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13770 #endif
13771 }
13772 {
13773 if (temp2)
13774 delete arg2;
13775 }
13776 return resultobj;
13777 fail:
13778 {
13779 if (temp2)
13780 delete arg2;
13781 }
13782 return NULL;
13783 }
13784
13785
13786 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13787 PyObject *resultobj = 0;
13788 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13789 wxString result;
13790 void *argp1 = 0 ;
13791 int res1 = 0 ;
13792 PyObject *swig_obj[1] ;
13793
13794 if (!args) SWIG_fail;
13795 swig_obj[0] = args;
13796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13797 if (!SWIG_IsOK(res1)) {
13798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13799 }
13800 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 result = (arg1)->FindNext();
13804 wxPyEndAllowThreads(__tstate);
13805 if (PyErr_Occurred()) SWIG_fail;
13806 }
13807 {
13808 #if wxUSE_UNICODE
13809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13810 #else
13811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13812 #endif
13813 }
13814 return resultobj;
13815 fail:
13816 return NULL;
13817 }
13818
13819
13820 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13821 PyObject *obj;
13822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13823 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13824 return SWIG_Py_Void();
13825 }
13826
13827 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13828 return SWIG_Python_InitShadowInstance(args);
13829 }
13830
13831 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13832 PyObject *resultobj = 0;
13833 wxString *arg1 = 0 ;
13834 wxImage *arg2 = 0 ;
13835 long arg3 ;
13836 bool temp1 = false ;
13837 void *argp2 = 0 ;
13838 int res2 = 0 ;
13839 long val3 ;
13840 int ecode3 = 0 ;
13841 PyObject * obj0 = 0 ;
13842 PyObject * obj1 = 0 ;
13843 PyObject * obj2 = 0 ;
13844 char * kwnames[] = {
13845 (char *) "filename",(char *) "image",(char *) "type", NULL
13846 };
13847
13848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13849 {
13850 arg1 = wxString_in_helper(obj0);
13851 if (arg1 == NULL) SWIG_fail;
13852 temp1 = true;
13853 }
13854 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13855 if (!SWIG_IsOK(res2)) {
13856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13857 }
13858 if (!argp2) {
13859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13860 }
13861 arg2 = reinterpret_cast< wxImage * >(argp2);
13862 ecode3 = SWIG_AsVal_long(obj2, &val3);
13863 if (!SWIG_IsOK(ecode3)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13865 }
13866 arg3 = static_cast< long >(val3);
13867 {
13868 PyThreadState* __tstate = wxPyBeginAllowThreads();
13869 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 resultobj = SWIG_Py_Void();
13874 {
13875 if (temp1)
13876 delete arg1;
13877 }
13878 return resultobj;
13879 fail:
13880 {
13881 if (temp1)
13882 delete arg1;
13883 }
13884 return NULL;
13885 }
13886
13887
13888 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj = 0;
13890 wxString *arg1 = 0 ;
13891 wxBitmap *arg2 = 0 ;
13892 long arg3 ;
13893 bool temp1 = false ;
13894 void *argp2 = 0 ;
13895 int res2 = 0 ;
13896 long val3 ;
13897 int ecode3 = 0 ;
13898 PyObject * obj0 = 0 ;
13899 PyObject * obj1 = 0 ;
13900 PyObject * obj2 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13906 {
13907 arg1 = wxString_in_helper(obj0);
13908 if (arg1 == NULL) SWIG_fail;
13909 temp1 = true;
13910 }
13911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13912 if (!SWIG_IsOK(res2)) {
13913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13914 }
13915 if (!argp2) {
13916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13917 }
13918 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13919 ecode3 = SWIG_AsVal_long(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13922 }
13923 arg3 = static_cast< long >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_Py_Void();
13931 {
13932 if (temp1)
13933 delete arg1;
13934 }
13935 return resultobj;
13936 fail:
13937 {
13938 if (temp1)
13939 delete arg1;
13940 }
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj = 0;
13947 wxString *arg1 = 0 ;
13948 PyObject *arg2 = (PyObject *) 0 ;
13949 bool temp1 = false ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "filename",(char *) "data", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13957 {
13958 arg1 = wxString_in_helper(obj0);
13959 if (arg1 == NULL) SWIG_fail;
13960 temp1 = true;
13961 }
13962 arg2 = obj1;
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 resultobj = SWIG_Py_Void();
13970 {
13971 if (temp1)
13972 delete arg1;
13973 }
13974 return resultobj;
13975 fail:
13976 {
13977 if (temp1)
13978 delete arg1;
13979 }
13980 return NULL;
13981 }
13982
13983
13984 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13985 PyObject *resultobj = 0;
13986 wxMemoryFSHandler *result = 0 ;
13987
13988 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13989 {
13990 PyThreadState* __tstate = wxPyBeginAllowThreads();
13991 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj = 0;
14004 wxString *arg1 = 0 ;
14005 bool temp1 = false ;
14006 PyObject * obj0 = 0 ;
14007 char * kwnames[] = {
14008 (char *) "filename", NULL
14009 };
14010
14011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14012 {
14013 arg1 = wxString_in_helper(obj0);
14014 if (arg1 == NULL) SWIG_fail;
14015 temp1 = true;
14016 }
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 resultobj = SWIG_Py_Void();
14024 {
14025 if (temp1)
14026 delete arg1;
14027 }
14028 return resultobj;
14029 fail:
14030 {
14031 if (temp1)
14032 delete arg1;
14033 }
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj = 0;
14040 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14041 wxString *arg2 = 0 ;
14042 bool result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 bool temp2 = false ;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 char * kwnames[] = {
14049 (char *) "self",(char *) "location", NULL
14050 };
14051
14052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14054 if (!SWIG_IsOK(res1)) {
14055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14056 }
14057 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14058 {
14059 arg2 = wxString_in_helper(obj1);
14060 if (arg2 == NULL) SWIG_fail;
14061 temp2 = true;
14062 }
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 {
14070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14071 }
14072 {
14073 if (temp2)
14074 delete arg2;
14075 }
14076 return resultobj;
14077 fail:
14078 {
14079 if (temp2)
14080 delete arg2;
14081 }
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj = 0;
14088 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14089 wxFileSystem *arg2 = 0 ;
14090 wxString *arg3 = 0 ;
14091 wxFSFile *result = 0 ;
14092 void *argp1 = 0 ;
14093 int res1 = 0 ;
14094 void *argp2 = 0 ;
14095 int res2 = 0 ;
14096 bool temp3 = false ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "fs",(char *) "location", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14108 }
14109 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14111 if (!SWIG_IsOK(res2)) {
14112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14113 }
14114 if (!argp2) {
14115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14116 }
14117 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14118 {
14119 arg3 = wxString_in_helper(obj2);
14120 if (arg3 == NULL) SWIG_fail;
14121 temp3 = true;
14122 }
14123 {
14124 PyThreadState* __tstate = wxPyBeginAllowThreads();
14125 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14126 wxPyEndAllowThreads(__tstate);
14127 if (PyErr_Occurred()) SWIG_fail;
14128 }
14129 {
14130 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14131 }
14132 {
14133 if (temp3)
14134 delete arg3;
14135 }
14136 return resultobj;
14137 fail:
14138 {
14139 if (temp3)
14140 delete arg3;
14141 }
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj = 0;
14148 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14149 wxString *arg2 = 0 ;
14150 int arg3 = (int) 0 ;
14151 wxString result;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 bool temp2 = false ;
14155 int val3 ;
14156 int ecode3 = 0 ;
14157 PyObject * obj0 = 0 ;
14158 PyObject * obj1 = 0 ;
14159 PyObject * obj2 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "self",(char *) "spec",(char *) "flags", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14168 }
14169 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14170 {
14171 arg2 = wxString_in_helper(obj1);
14172 if (arg2 == NULL) SWIG_fail;
14173 temp2 = true;
14174 }
14175 if (obj2) {
14176 ecode3 = SWIG_AsVal_int(obj2, &val3);
14177 if (!SWIG_IsOK(ecode3)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14179 }
14180 arg3 = static_cast< int >(val3);
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 #if wxUSE_UNICODE
14190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14191 #else
14192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14193 #endif
14194 }
14195 {
14196 if (temp2)
14197 delete arg2;
14198 }
14199 return resultobj;
14200 fail:
14201 {
14202 if (temp2)
14203 delete arg2;
14204 }
14205 return NULL;
14206 }
14207
14208
14209 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14210 PyObject *resultobj = 0;
14211 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14212 wxString result;
14213 void *argp1 = 0 ;
14214 int res1 = 0 ;
14215 PyObject *swig_obj[1] ;
14216
14217 if (!args) SWIG_fail;
14218 swig_obj[0] = args;
14219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14220 if (!SWIG_IsOK(res1)) {
14221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14222 }
14223 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (arg1)->FindNext();
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 {
14231 #if wxUSE_UNICODE
14232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14233 #else
14234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14235 #endif
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14244 PyObject *obj;
14245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14246 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14247 return SWIG_Py_Void();
14248 }
14249
14250 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14251 return SWIG_Python_InitShadowInstance(args);
14252 }
14253
14254 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14255 PyObject *resultobj = 0;
14256 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14257 wxString result;
14258 void *argp1 = 0 ;
14259 int res1 = 0 ;
14260 PyObject *swig_obj[1] ;
14261
14262 if (!args) SWIG_fail;
14263 swig_obj[0] = args;
14264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14265 if (!SWIG_IsOK(res1)) {
14266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14267 }
14268 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 result = (arg1)->GetName();
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 {
14276 #if wxUSE_UNICODE
14277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14278 #else
14279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14280 #endif
14281 }
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14289 PyObject *resultobj = 0;
14290 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14291 wxString result;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 PyObject *swig_obj[1] ;
14295
14296 if (!args) SWIG_fail;
14297 swig_obj[0] = args;
14298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14299 if (!SWIG_IsOK(res1)) {
14300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14301 }
14302 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (arg1)->GetExtension();
14306 wxPyEndAllowThreads(__tstate);
14307 if (PyErr_Occurred()) SWIG_fail;
14308 }
14309 {
14310 #if wxUSE_UNICODE
14311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14312 #else
14313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14314 #endif
14315 }
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14323 PyObject *resultobj = 0;
14324 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14325 long result;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 PyObject *swig_obj[1] ;
14329
14330 if (!args) SWIG_fail;
14331 swig_obj[0] = args;
14332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14335 }
14336 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (long)(arg1)->GetType();
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_From_long(static_cast< long >(result));
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14351 PyObject *resultobj = 0;
14352 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14353 wxString result;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 PyObject *swig_obj[1] ;
14357
14358 if (!args) SWIG_fail;
14359 swig_obj[0] = args;
14360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14363 }
14364 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (arg1)->GetMimeType();
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 #if wxUSE_UNICODE
14373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14374 #else
14375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14376 #endif
14377 }
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14385 PyObject *resultobj = 0;
14386 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14387 wxString *arg2 = 0 ;
14388 bool result;
14389 void *argp1 = 0 ;
14390 int res1 = 0 ;
14391 bool temp2 = false ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 char * kwnames[] = {
14395 (char *) "self",(char *) "name", NULL
14396 };
14397
14398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14402 }
14403 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14404 {
14405 arg2 = wxString_in_helper(obj1);
14406 if (arg2 == NULL) SWIG_fail;
14407 temp2 = true;
14408 }
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14417 }
14418 {
14419 if (temp2)
14420 delete arg2;
14421 }
14422 return resultobj;
14423 fail:
14424 {
14425 if (temp2)
14426 delete arg2;
14427 }
14428 return NULL;
14429 }
14430
14431
14432 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj = 0;
14434 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14435 wxInputStream *arg2 = 0 ;
14436 bool result;
14437 void *argp1 = 0 ;
14438 int res1 = 0 ;
14439 wxPyInputStream *temp2 ;
14440 bool created2 ;
14441 PyObject * obj0 = 0 ;
14442 PyObject * obj1 = 0 ;
14443 char * kwnames[] = {
14444 (char *) "self",(char *) "stream", NULL
14445 };
14446
14447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14449 if (!SWIG_IsOK(res1)) {
14450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14451 }
14452 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14453 {
14454 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14455 arg2 = temp2->m_wxis;
14456 created2 = false;
14457 } else {
14458 PyErr_Clear(); // clear the failure of the wxPyConvert above
14459 arg2 = wxPyCBInputStream_create(obj1, false);
14460 if (arg2 == NULL) {
14461 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14462 SWIG_fail;
14463 }
14464 created2 = true;
14465 }
14466 }
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (bool)(arg1)->CanRead(*arg2);
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 {
14474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14475 }
14476 {
14477 if (created2) delete arg2;
14478 }
14479 return resultobj;
14480 fail:
14481 {
14482 if (created2) delete arg2;
14483 }
14484 return NULL;
14485 }
14486
14487
14488 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14489 PyObject *resultobj = 0;
14490 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14491 wxString *arg2 = 0 ;
14492 void *argp1 = 0 ;
14493 int res1 = 0 ;
14494 bool temp2 = false ;
14495 PyObject * obj0 = 0 ;
14496 PyObject * obj1 = 0 ;
14497 char * kwnames[] = {
14498 (char *) "self",(char *) "name", NULL
14499 };
14500
14501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14503 if (!SWIG_IsOK(res1)) {
14504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14505 }
14506 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14507 {
14508 arg2 = wxString_in_helper(obj1);
14509 if (arg2 == NULL) SWIG_fail;
14510 temp2 = true;
14511 }
14512 {
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 (arg1)->SetName((wxString const &)*arg2);
14515 wxPyEndAllowThreads(__tstate);
14516 if (PyErr_Occurred()) SWIG_fail;
14517 }
14518 resultobj = SWIG_Py_Void();
14519 {
14520 if (temp2)
14521 delete arg2;
14522 }
14523 return resultobj;
14524 fail:
14525 {
14526 if (temp2)
14527 delete arg2;
14528 }
14529 return NULL;
14530 }
14531
14532
14533 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14534 PyObject *resultobj = 0;
14535 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14536 wxString *arg2 = 0 ;
14537 void *argp1 = 0 ;
14538 int res1 = 0 ;
14539 bool temp2 = false ;
14540 PyObject * obj0 = 0 ;
14541 PyObject * obj1 = 0 ;
14542 char * kwnames[] = {
14543 (char *) "self",(char *) "extension", NULL
14544 };
14545
14546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14548 if (!SWIG_IsOK(res1)) {
14549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14550 }
14551 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14552 {
14553 arg2 = wxString_in_helper(obj1);
14554 if (arg2 == NULL) SWIG_fail;
14555 temp2 = true;
14556 }
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 (arg1)->SetExtension((wxString const &)*arg2);
14560 wxPyEndAllowThreads(__tstate);
14561 if (PyErr_Occurred()) SWIG_fail;
14562 }
14563 resultobj = SWIG_Py_Void();
14564 {
14565 if (temp2)
14566 delete arg2;
14567 }
14568 return resultobj;
14569 fail:
14570 {
14571 if (temp2)
14572 delete arg2;
14573 }
14574 return NULL;
14575 }
14576
14577
14578 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj = 0;
14580 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14581 long arg2 ;
14582 void *argp1 = 0 ;
14583 int res1 = 0 ;
14584 long val2 ;
14585 int ecode2 = 0 ;
14586 PyObject * obj0 = 0 ;
14587 PyObject * obj1 = 0 ;
14588 char * kwnames[] = {
14589 (char *) "self",(char *) "type", NULL
14590 };
14591
14592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14596 }
14597 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14598 ecode2 = SWIG_AsVal_long(obj1, &val2);
14599 if (!SWIG_IsOK(ecode2)) {
14600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14601 }
14602 arg2 = static_cast< long >(val2);
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 (arg1)->SetType(arg2);
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 resultobj = SWIG_Py_Void();
14610 return resultobj;
14611 fail:
14612 return NULL;
14613 }
14614
14615
14616 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj = 0;
14618 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14619 wxString *arg2 = 0 ;
14620 void *argp1 = 0 ;
14621 int res1 = 0 ;
14622 bool temp2 = false ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 char * kwnames[] = {
14626 (char *) "self",(char *) "mimetype", NULL
14627 };
14628
14629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14631 if (!SWIG_IsOK(res1)) {
14632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14633 }
14634 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14635 {
14636 arg2 = wxString_in_helper(obj1);
14637 if (arg2 == NULL) SWIG_fail;
14638 temp2 = true;
14639 }
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 (arg1)->SetMimeType((wxString const &)*arg2);
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 resultobj = SWIG_Py_Void();
14647 {
14648 if (temp2)
14649 delete arg2;
14650 }
14651 return resultobj;
14652 fail:
14653 {
14654 if (temp2)
14655 delete arg2;
14656 }
14657 return NULL;
14658 }
14659
14660
14661 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14662 PyObject *obj;
14663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14664 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14665 return SWIG_Py_Void();
14666 }
14667
14668 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14669 PyObject *resultobj = 0;
14670 wxPyImageHandler *result = 0 ;
14671
14672 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14673 {
14674 PyThreadState* __tstate = wxPyBeginAllowThreads();
14675 result = (wxPyImageHandler *)new wxPyImageHandler();
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14680 return resultobj;
14681 fail:
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj = 0;
14688 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14689 PyObject *arg2 = (PyObject *) 0 ;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 char * kwnames[] = {
14695 (char *) "self",(char *) "self", NULL
14696 };
14697
14698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14700 if (!SWIG_IsOK(res1)) {
14701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14702 }
14703 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14704 arg2 = obj1;
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 (arg1)->_SetSelf(arg2);
14708 wxPyEndAllowThreads(__tstate);
14709 if (PyErr_Occurred()) SWIG_fail;
14710 }
14711 resultobj = SWIG_Py_Void();
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14719 PyObject *obj;
14720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14721 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14722 return SWIG_Py_Void();
14723 }
14724
14725 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14726 return SWIG_Python_InitShadowInstance(args);
14727 }
14728
14729 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxImageHistogram *result = 0 ;
14732
14733 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (wxImageHistogram *)new wxImageHistogram();
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14741 return resultobj;
14742 fail:
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj = 0;
14749 byte arg1 ;
14750 byte arg2 ;
14751 byte arg3 ;
14752 unsigned long result;
14753 unsigned char val1 ;
14754 int ecode1 = 0 ;
14755 unsigned char val2 ;
14756 int ecode2 = 0 ;
14757 unsigned char val3 ;
14758 int ecode3 = 0 ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 PyObject * obj2 = 0 ;
14762 char * kwnames[] = {
14763 (char *) "r",(char *) "g",(char *) "b", NULL
14764 };
14765
14766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14767 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14768 if (!SWIG_IsOK(ecode1)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14770 }
14771 arg1 = static_cast< byte >(val1);
14772 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14773 if (!SWIG_IsOK(ecode2)) {
14774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14775 }
14776 arg2 = static_cast< byte >(val2);
14777 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14778 if (!SWIG_IsOK(ecode3)) {
14779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14780 }
14781 arg3 = static_cast< byte >(val3);
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14789 return resultobj;
14790 fail:
14791 return NULL;
14792 }
14793
14794
14795 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14796 PyObject *resultobj = 0;
14797 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14798 byte *arg2 = (byte *) 0 ;
14799 byte *arg3 = (byte *) 0 ;
14800 byte *arg4 = (byte *) 0 ;
14801 byte arg5 = (byte) 1 ;
14802 byte arg6 = (byte) 0 ;
14803 byte arg7 = (byte) 0 ;
14804 bool result;
14805 void *argp1 = 0 ;
14806 int res1 = 0 ;
14807 byte temp2 ;
14808 int res2 = SWIG_TMPOBJ ;
14809 byte temp3 ;
14810 int res3 = SWIG_TMPOBJ ;
14811 byte temp4 ;
14812 int res4 = SWIG_TMPOBJ ;
14813 unsigned char val5 ;
14814 int ecode5 = 0 ;
14815 unsigned char val6 ;
14816 int ecode6 = 0 ;
14817 unsigned char val7 ;
14818 int ecode7 = 0 ;
14819 PyObject * obj0 = 0 ;
14820 PyObject * obj1 = 0 ;
14821 PyObject * obj2 = 0 ;
14822 PyObject * obj3 = 0 ;
14823 char * kwnames[] = {
14824 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14825 };
14826
14827 arg2 = &temp2;
14828 arg3 = &temp3;
14829 arg4 = &temp4;
14830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14834 }
14835 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14836 if (obj1) {
14837 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14838 if (!SWIG_IsOK(ecode5)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14840 }
14841 arg5 = static_cast< byte >(val5);
14842 }
14843 if (obj2) {
14844 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14845 if (!SWIG_IsOK(ecode6)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14847 }
14848 arg6 = static_cast< byte >(val6);
14849 }
14850 if (obj3) {
14851 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14852 if (!SWIG_IsOK(ecode7)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14854 }
14855 arg7 = static_cast< byte >(val7);
14856 }
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 {
14864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14865 }
14866 if (SWIG_IsTmpObj(res2)) {
14867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14868 } else {
14869 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14871 }
14872 if (SWIG_IsTmpObj(res3)) {
14873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14874 } else {
14875 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14877 }
14878 if (SWIG_IsTmpObj(res4)) {
14879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14880 } else {
14881 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14883 }
14884 return resultobj;
14885 fail:
14886 return NULL;
14887 }
14888
14889
14890 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj = 0;
14892 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14893 unsigned long arg2 ;
14894 unsigned long result;
14895 void *argp1 = 0 ;
14896 int res1 = 0 ;
14897 unsigned long val2 ;
14898 int ecode2 = 0 ;
14899 PyObject * obj0 = 0 ;
14900 PyObject * obj1 = 0 ;
14901 char * kwnames[] = {
14902 (char *) "self",(char *) "key", NULL
14903 };
14904
14905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14907 if (!SWIG_IsOK(res1)) {
14908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14909 }
14910 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14911 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14912 if (!SWIG_IsOK(ecode2)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14914 }
14915 arg2 = static_cast< unsigned long >(val2);
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14923 return resultobj;
14924 fail:
14925 return NULL;
14926 }
14927
14928
14929 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14930 PyObject *resultobj = 0;
14931 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14932 byte arg2 ;
14933 byte arg3 ;
14934 byte arg4 ;
14935 unsigned long result;
14936 void *argp1 = 0 ;
14937 int res1 = 0 ;
14938 unsigned char val2 ;
14939 int ecode2 = 0 ;
14940 unsigned char val3 ;
14941 int ecode3 = 0 ;
14942 unsigned char val4 ;
14943 int ecode4 = 0 ;
14944 PyObject * obj0 = 0 ;
14945 PyObject * obj1 = 0 ;
14946 PyObject * obj2 = 0 ;
14947 PyObject * obj3 = 0 ;
14948 char * kwnames[] = {
14949 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14950 };
14951
14952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14954 if (!SWIG_IsOK(res1)) {
14955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14956 }
14957 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14958 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14959 if (!SWIG_IsOK(ecode2)) {
14960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14961 }
14962 arg2 = static_cast< byte >(val2);
14963 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14964 if (!SWIG_IsOK(ecode3)) {
14965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14966 }
14967 arg3 = static_cast< byte >(val3);
14968 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14969 if (!SWIG_IsOK(ecode4)) {
14970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14971 }
14972 arg4 = static_cast< byte >(val4);
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14989 wxColour *arg2 = 0 ;
14990 unsigned long result;
14991 void *argp1 = 0 ;
14992 int res1 = 0 ;
14993 wxColour temp2 ;
14994 PyObject * obj0 = 0 ;
14995 PyObject * obj1 = 0 ;
14996 char * kwnames[] = {
14997 (char *) "self",(char *) "colour", NULL
14998 };
14999
15000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15002 if (!SWIG_IsOK(res1)) {
15003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15004 }
15005 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15006 {
15007 arg2 = &temp2;
15008 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15009 }
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024 PyObject *obj;
15025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15026 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15027 return SWIG_Py_Void();
15028 }
15029
15030 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031 return SWIG_Python_InitShadowInstance(args);
15032 }
15033
15034 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15035 PyObject *resultobj = 0;
15036 byte arg1 = (byte) 0 ;
15037 byte arg2 = (byte) 0 ;
15038 byte arg3 = (byte) 0 ;
15039 wxImage_RGBValue *result = 0 ;
15040 unsigned char val1 ;
15041 int ecode1 = 0 ;
15042 unsigned char val2 ;
15043 int ecode2 = 0 ;
15044 unsigned char val3 ;
15045 int ecode3 = 0 ;
15046 PyObject * obj0 = 0 ;
15047 PyObject * obj1 = 0 ;
15048 PyObject * obj2 = 0 ;
15049 char * kwnames[] = {
15050 (char *) "r",(char *) "g",(char *) "b", NULL
15051 };
15052
15053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15054 if (obj0) {
15055 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15056 if (!SWIG_IsOK(ecode1)) {
15057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15058 }
15059 arg1 = static_cast< byte >(val1);
15060 }
15061 if (obj1) {
15062 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15063 if (!SWIG_IsOK(ecode2)) {
15064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15065 }
15066 arg2 = static_cast< byte >(val2);
15067 }
15068 if (obj2) {
15069 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15070 if (!SWIG_IsOK(ecode3)) {
15071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15072 }
15073 arg3 = static_cast< byte >(val3);
15074 }
15075 {
15076 PyThreadState* __tstate = wxPyBeginAllowThreads();
15077 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15078 wxPyEndAllowThreads(__tstate);
15079 if (PyErr_Occurred()) SWIG_fail;
15080 }
15081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15082 return resultobj;
15083 fail:
15084 return NULL;
15085 }
15086
15087
15088 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15089 PyObject *resultobj = 0;
15090 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15091 byte arg2 ;
15092 void *argp1 = 0 ;
15093 int res1 = 0 ;
15094 unsigned char val2 ;
15095 int ecode2 = 0 ;
15096 PyObject *swig_obj[2] ;
15097
15098 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15100 if (!SWIG_IsOK(res1)) {
15101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15102 }
15103 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15104 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15105 if (!SWIG_IsOK(ecode2)) {
15106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15107 }
15108 arg2 = static_cast< byte >(val2);
15109 if (arg1) (arg1)->red = arg2;
15110
15111 resultobj = SWIG_Py_Void();
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15119 PyObject *resultobj = 0;
15120 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15121 byte result;
15122 void *argp1 = 0 ;
15123 int res1 = 0 ;
15124 PyObject *swig_obj[1] ;
15125
15126 if (!args) SWIG_fail;
15127 swig_obj[0] = args;
15128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15129 if (!SWIG_IsOK(res1)) {
15130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15131 }
15132 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15133 result = (byte) ((arg1)->red);
15134 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15135 return resultobj;
15136 fail:
15137 return NULL;
15138 }
15139
15140
15141 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15142 PyObject *resultobj = 0;
15143 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15144 byte arg2 ;
15145 void *argp1 = 0 ;
15146 int res1 = 0 ;
15147 unsigned char val2 ;
15148 int ecode2 = 0 ;
15149 PyObject *swig_obj[2] ;
15150
15151 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15157 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15158 if (!SWIG_IsOK(ecode2)) {
15159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15160 }
15161 arg2 = static_cast< byte >(val2);
15162 if (arg1) (arg1)->green = arg2;
15163
15164 resultobj = SWIG_Py_Void();
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15172 PyObject *resultobj = 0;
15173 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15174 byte result;
15175 void *argp1 = 0 ;
15176 int res1 = 0 ;
15177 PyObject *swig_obj[1] ;
15178
15179 if (!args) SWIG_fail;
15180 swig_obj[0] = args;
15181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15184 }
15185 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15186 result = (byte) ((arg1)->green);
15187 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *resultobj = 0;
15196 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15197 byte arg2 ;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 unsigned char val2 ;
15201 int ecode2 = 0 ;
15202 PyObject *swig_obj[2] ;
15203
15204 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15208 }
15209 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15210 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15211 if (!SWIG_IsOK(ecode2)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15213 }
15214 arg2 = static_cast< byte >(val2);
15215 if (arg1) (arg1)->blue = arg2;
15216
15217 resultobj = SWIG_Py_Void();
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15225 PyObject *resultobj = 0;
15226 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15227 byte result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 PyObject *swig_obj[1] ;
15231
15232 if (!args) SWIG_fail;
15233 swig_obj[0] = args;
15234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15237 }
15238 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15239 result = (byte) ((arg1)->blue);
15240 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15241 return resultobj;
15242 fail:
15243 return NULL;
15244 }
15245
15246
15247 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15248 PyObject *obj;
15249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15250 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15251 return SWIG_Py_Void();
15252 }
15253
15254 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15255 return SWIG_Python_InitShadowInstance(args);
15256 }
15257
15258 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj = 0;
15260 double arg1 = (double) 0.0 ;
15261 double arg2 = (double) 0.0 ;
15262 double arg3 = (double) 0.0 ;
15263 wxImage_HSVValue *result = 0 ;
15264 double val1 ;
15265 int ecode1 = 0 ;
15266 double val2 ;
15267 int ecode2 = 0 ;
15268 double val3 ;
15269 int ecode3 = 0 ;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 PyObject * obj2 = 0 ;
15273 char * kwnames[] = {
15274 (char *) "h",(char *) "s",(char *) "v", NULL
15275 };
15276
15277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15278 if (obj0) {
15279 ecode1 = SWIG_AsVal_double(obj0, &val1);
15280 if (!SWIG_IsOK(ecode1)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15282 }
15283 arg1 = static_cast< double >(val1);
15284 }
15285 if (obj1) {
15286 ecode2 = SWIG_AsVal_double(obj1, &val2);
15287 if (!SWIG_IsOK(ecode2)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15289 }
15290 arg2 = static_cast< double >(val2);
15291 }
15292 if (obj2) {
15293 ecode3 = SWIG_AsVal_double(obj2, &val3);
15294 if (!SWIG_IsOK(ecode3)) {
15295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15296 }
15297 arg3 = static_cast< double >(val3);
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15313 PyObject *resultobj = 0;
15314 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15315 double arg2 ;
15316 void *argp1 = 0 ;
15317 int res1 = 0 ;
15318 double val2 ;
15319 int ecode2 = 0 ;
15320 PyObject *swig_obj[2] ;
15321
15322 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15324 if (!SWIG_IsOK(res1)) {
15325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15326 }
15327 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15328 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15329 if (!SWIG_IsOK(ecode2)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15331 }
15332 arg2 = static_cast< double >(val2);
15333 if (arg1) (arg1)->hue = arg2;
15334
15335 resultobj = SWIG_Py_Void();
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15343 PyObject *resultobj = 0;
15344 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15345 double result;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 PyObject *swig_obj[1] ;
15349
15350 if (!args) SWIG_fail;
15351 swig_obj[0] = args;
15352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15353 if (!SWIG_IsOK(res1)) {
15354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15355 }
15356 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15357 result = (double) ((arg1)->hue);
15358 resultobj = SWIG_From_double(static_cast< double >(result));
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15366 PyObject *resultobj = 0;
15367 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15368 double arg2 ;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 double val2 ;
15372 int ecode2 = 0 ;
15373 PyObject *swig_obj[2] ;
15374
15375 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15379 }
15380 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15381 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15382 if (!SWIG_IsOK(ecode2)) {
15383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15384 }
15385 arg2 = static_cast< double >(val2);
15386 if (arg1) (arg1)->saturation = arg2;
15387
15388 resultobj = SWIG_Py_Void();
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 PyObject *resultobj = 0;
15397 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15398 double result;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject *swig_obj[1] ;
15402
15403 if (!args) SWIG_fail;
15404 swig_obj[0] = args;
15405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15408 }
15409 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15410 result = (double) ((arg1)->saturation);
15411 resultobj = SWIG_From_double(static_cast< double >(result));
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15419 PyObject *resultobj = 0;
15420 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15421 double arg2 ;
15422 void *argp1 = 0 ;
15423 int res1 = 0 ;
15424 double val2 ;
15425 int ecode2 = 0 ;
15426 PyObject *swig_obj[2] ;
15427
15428 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15430 if (!SWIG_IsOK(res1)) {
15431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15432 }
15433 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15434 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15435 if (!SWIG_IsOK(ecode2)) {
15436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15437 }
15438 arg2 = static_cast< double >(val2);
15439 if (arg1) (arg1)->value = arg2;
15440
15441 resultobj = SWIG_Py_Void();
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449 PyObject *resultobj = 0;
15450 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15451 double result;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 PyObject *swig_obj[1] ;
15455
15456 if (!args) SWIG_fail;
15457 swig_obj[0] = args;
15458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15459 if (!SWIG_IsOK(res1)) {
15460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15461 }
15462 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15463 result = (double) ((arg1)->value);
15464 resultobj = SWIG_From_double(static_cast< double >(result));
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15472 PyObject *obj;
15473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15474 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15475 return SWIG_Py_Void();
15476 }
15477
15478 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15479 return SWIG_Python_InitShadowInstance(args);
15480 }
15481
15482 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj = 0;
15484 wxString *arg1 = 0 ;
15485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15486 int arg3 = (int) -1 ;
15487 wxImage *result = 0 ;
15488 bool temp1 = false ;
15489 long val2 ;
15490 int ecode2 = 0 ;
15491 int val3 ;
15492 int ecode3 = 0 ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 PyObject * obj2 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "name",(char *) "type",(char *) "index", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15501 {
15502 arg1 = wxString_in_helper(obj0);
15503 if (arg1 == NULL) SWIG_fail;
15504 temp1 = true;
15505 }
15506 if (obj1) {
15507 ecode2 = SWIG_AsVal_long(obj1, &val2);
15508 if (!SWIG_IsOK(ecode2)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15510 }
15511 arg2 = static_cast< long >(val2);
15512 }
15513 if (obj2) {
15514 ecode3 = SWIG_AsVal_int(obj2, &val3);
15515 if (!SWIG_IsOK(ecode3)) {
15516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15517 }
15518 arg3 = static_cast< int >(val3);
15519 }
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15527 {
15528 if (temp1)
15529 delete arg1;
15530 }
15531 return resultobj;
15532 fail:
15533 {
15534 if (temp1)
15535 delete arg1;
15536 }
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15542 PyObject *resultobj = 0;
15543 wxImage *arg1 = (wxImage *) 0 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 PyObject *swig_obj[1] ;
15547
15548 if (!args) SWIG_fail;
15549 swig_obj[0] = args;
15550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15553 }
15554 arg1 = reinterpret_cast< wxImage * >(argp1);
15555 {
15556 PyThreadState* __tstate = wxPyBeginAllowThreads();
15557 delete arg1;
15558
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 resultobj = SWIG_Py_Void();
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15570 PyObject *resultobj = 0;
15571 wxString *arg1 = 0 ;
15572 wxString *arg2 = 0 ;
15573 int arg3 = (int) -1 ;
15574 wxImage *result = 0 ;
15575 bool temp1 = false ;
15576 bool temp2 = false ;
15577 int val3 ;
15578 int ecode3 = 0 ;
15579 PyObject * obj0 = 0 ;
15580 PyObject * obj1 = 0 ;
15581 PyObject * obj2 = 0 ;
15582 char * kwnames[] = {
15583 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15584 };
15585
15586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15587 {
15588 arg1 = wxString_in_helper(obj0);
15589 if (arg1 == NULL) SWIG_fail;
15590 temp1 = true;
15591 }
15592 {
15593 arg2 = wxString_in_helper(obj1);
15594 if (arg2 == NULL) SWIG_fail;
15595 temp2 = true;
15596 }
15597 if (obj2) {
15598 ecode3 = SWIG_AsVal_int(obj2, &val3);
15599 if (!SWIG_IsOK(ecode3)) {
15600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15601 }
15602 arg3 = static_cast< int >(val3);
15603 }
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15611 {
15612 if (temp1)
15613 delete arg1;
15614 }
15615 {
15616 if (temp2)
15617 delete arg2;
15618 }
15619 return resultobj;
15620 fail:
15621 {
15622 if (temp1)
15623 delete arg1;
15624 }
15625 {
15626 if (temp2)
15627 delete arg2;
15628 }
15629 return NULL;
15630 }
15631
15632
15633 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj = 0;
15635 wxInputStream *arg1 = 0 ;
15636 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15637 int arg3 = (int) -1 ;
15638 wxImage *result = 0 ;
15639 wxPyInputStream *temp1 ;
15640 bool created1 ;
15641 long val2 ;
15642 int ecode2 = 0 ;
15643 int val3 ;
15644 int ecode3 = 0 ;
15645 PyObject * obj0 = 0 ;
15646 PyObject * obj1 = 0 ;
15647 PyObject * obj2 = 0 ;
15648 char * kwnames[] = {
15649 (char *) "stream",(char *) "type",(char *) "index", NULL
15650 };
15651
15652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15653 {
15654 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15655 arg1 = temp1->m_wxis;
15656 created1 = false;
15657 } else {
15658 PyErr_Clear(); // clear the failure of the wxPyConvert above
15659 arg1 = wxPyCBInputStream_create(obj0, false);
15660 if (arg1 == NULL) {
15661 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15662 SWIG_fail;
15663 }
15664 created1 = true;
15665 }
15666 }
15667 if (obj1) {
15668 ecode2 = SWIG_AsVal_long(obj1, &val2);
15669 if (!SWIG_IsOK(ecode2)) {
15670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15671 }
15672 arg2 = static_cast< long >(val2);
15673 }
15674 if (obj2) {
15675 ecode3 = SWIG_AsVal_int(obj2, &val3);
15676 if (!SWIG_IsOK(ecode3)) {
15677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15678 }
15679 arg3 = static_cast< int >(val3);
15680 }
15681 {
15682 PyThreadState* __tstate = wxPyBeginAllowThreads();
15683 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15688 {
15689 if (created1) delete arg1;
15690 }
15691 return resultobj;
15692 fail:
15693 {
15694 if (created1) delete arg1;
15695 }
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15701 PyObject *resultobj = 0;
15702 wxInputStream *arg1 = 0 ;
15703 wxString *arg2 = 0 ;
15704 int arg3 = (int) -1 ;
15705 wxImage *result = 0 ;
15706 wxPyInputStream *temp1 ;
15707 bool created1 ;
15708 bool temp2 = false ;
15709 int val3 ;
15710 int ecode3 = 0 ;
15711 PyObject * obj0 = 0 ;
15712 PyObject * obj1 = 0 ;
15713 PyObject * obj2 = 0 ;
15714 char * kwnames[] = {
15715 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15716 };
15717
15718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15719 {
15720 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15721 arg1 = temp1->m_wxis;
15722 created1 = false;
15723 } else {
15724 PyErr_Clear(); // clear the failure of the wxPyConvert above
15725 arg1 = wxPyCBInputStream_create(obj0, false);
15726 if (arg1 == NULL) {
15727 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15728 SWIG_fail;
15729 }
15730 created1 = true;
15731 }
15732 }
15733 {
15734 arg2 = wxString_in_helper(obj1);
15735 if (arg2 == NULL) SWIG_fail;
15736 temp2 = true;
15737 }
15738 if (obj2) {
15739 ecode3 = SWIG_AsVal_int(obj2, &val3);
15740 if (!SWIG_IsOK(ecode3)) {
15741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15742 }
15743 arg3 = static_cast< int >(val3);
15744 }
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15752 {
15753 if (created1) delete arg1;
15754 }
15755 {
15756 if (temp2)
15757 delete arg2;
15758 }
15759 return resultobj;
15760 fail:
15761 {
15762 if (created1) delete arg1;
15763 }
15764 {
15765 if (temp2)
15766 delete arg2;
15767 }
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj = 0;
15774 int arg1 = (int) 0 ;
15775 int arg2 = (int) 0 ;
15776 bool arg3 = (bool) true ;
15777 wxImage *result = 0 ;
15778 int val1 ;
15779 int ecode1 = 0 ;
15780 int val2 ;
15781 int ecode2 = 0 ;
15782 bool val3 ;
15783 int ecode3 = 0 ;
15784 PyObject * obj0 = 0 ;
15785 PyObject * obj1 = 0 ;
15786 PyObject * obj2 = 0 ;
15787 char * kwnames[] = {
15788 (char *) "width",(char *) "height",(char *) "clear", NULL
15789 };
15790
15791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15792 if (obj0) {
15793 ecode1 = SWIG_AsVal_int(obj0, &val1);
15794 if (!SWIG_IsOK(ecode1)) {
15795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15796 }
15797 arg1 = static_cast< int >(val1);
15798 }
15799 if (obj1) {
15800 ecode2 = SWIG_AsVal_int(obj1, &val2);
15801 if (!SWIG_IsOK(ecode2)) {
15802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15803 }
15804 arg2 = static_cast< int >(val2);
15805 }
15806 if (obj2) {
15807 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15808 if (!SWIG_IsOK(ecode3)) {
15809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15810 }
15811 arg3 = static_cast< bool >(val3);
15812 }
15813 {
15814 PyThreadState* __tstate = wxPyBeginAllowThreads();
15815 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15816 wxPyEndAllowThreads(__tstate);
15817 if (PyErr_Occurred()) SWIG_fail;
15818 }
15819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15820 return resultobj;
15821 fail:
15822 return NULL;
15823 }
15824
15825
15826 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15827 PyObject *resultobj = 0;
15828 wxBitmap *arg1 = 0 ;
15829 wxImage *result = 0 ;
15830 void *argp1 = 0 ;
15831 int res1 = 0 ;
15832 PyObject * obj0 = 0 ;
15833 char * kwnames[] = {
15834 (char *) "bitmap", NULL
15835 };
15836
15837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15838 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15839 if (!SWIG_IsOK(res1)) {
15840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15841 }
15842 if (!argp1) {
15843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15844 }
15845 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15846 {
15847 if (!wxPyCheckForApp()) SWIG_fail;
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15861 PyObject *resultobj = 0;
15862 int arg1 ;
15863 int arg2 ;
15864 buffer arg3 ;
15865 int arg4 ;
15866 wxImage *result = 0 ;
15867 int val1 ;
15868 int ecode1 = 0 ;
15869 int val2 ;
15870 int ecode2 = 0 ;
15871 Py_ssize_t temp3 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 PyObject * obj2 = 0 ;
15875 char * kwnames[] = {
15876 (char *) "width",(char *) "height",(char *) "data", NULL
15877 };
15878
15879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15880 ecode1 = SWIG_AsVal_int(obj0, &val1);
15881 if (!SWIG_IsOK(ecode1)) {
15882 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15883 }
15884 arg1 = static_cast< int >(val1);
15885 ecode2 = SWIG_AsVal_int(obj1, &val2);
15886 if (!SWIG_IsOK(ecode2)) {
15887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15888 }
15889 arg2 = static_cast< int >(val2);
15890 {
15891 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15892 arg4 = (int)temp3;
15893 }
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15908 PyObject *resultobj = 0;
15909 int arg1 ;
15910 int arg2 ;
15911 buffer arg3 ;
15912 int arg4 ;
15913 buffer arg5 ;
15914 int arg6 ;
15915 wxImage *result = 0 ;
15916 int val1 ;
15917 int ecode1 = 0 ;
15918 int val2 ;
15919 int ecode2 = 0 ;
15920 Py_ssize_t temp3 ;
15921 Py_ssize_t temp5 ;
15922 PyObject * obj0 = 0 ;
15923 PyObject * obj1 = 0 ;
15924 PyObject * obj2 = 0 ;
15925 PyObject * obj3 = 0 ;
15926 char * kwnames[] = {
15927 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15928 };
15929
15930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15931 ecode1 = SWIG_AsVal_int(obj0, &val1);
15932 if (!SWIG_IsOK(ecode1)) {
15933 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15934 }
15935 arg1 = static_cast< int >(val1);
15936 ecode2 = SWIG_AsVal_int(obj1, &val2);
15937 if (!SWIG_IsOK(ecode2)) {
15938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15939 }
15940 arg2 = static_cast< int >(val2);
15941 {
15942 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15943 arg4 = (int)temp3;
15944 }
15945 {
15946 if (obj3 != Py_None) {
15947 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15948 arg6 = (int)temp5;
15949 }
15950 }
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15965 PyObject *resultobj = 0;
15966 wxImage *arg1 = (wxImage *) 0 ;
15967 int arg2 ;
15968 int arg3 ;
15969 bool arg4 = (bool) true ;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 int val2 ;
15973 int ecode2 = 0 ;
15974 int val3 ;
15975 int ecode3 = 0 ;
15976 bool val4 ;
15977 int ecode4 = 0 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 PyObject * obj2 = 0 ;
15981 PyObject * obj3 = 0 ;
15982 char * kwnames[] = {
15983 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15984 };
15985
15986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15990 }
15991 arg1 = reinterpret_cast< wxImage * >(argp1);
15992 ecode2 = SWIG_AsVal_int(obj1, &val2);
15993 if (!SWIG_IsOK(ecode2)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15995 }
15996 arg2 = static_cast< int >(val2);
15997 ecode3 = SWIG_AsVal_int(obj2, &val3);
15998 if (!SWIG_IsOK(ecode3)) {
15999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16000 }
16001 arg3 = static_cast< int >(val3);
16002 if (obj3) {
16003 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16004 if (!SWIG_IsOK(ecode4)) {
16005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16006 }
16007 arg4 = static_cast< bool >(val4);
16008 }
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 (arg1)->Create(arg2,arg3,arg4);
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 resultobj = SWIG_Py_Void();
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16023 PyObject *resultobj = 0;
16024 wxImage *arg1 = (wxImage *) 0 ;
16025 void *argp1 = 0 ;
16026 int res1 = 0 ;
16027 PyObject *swig_obj[1] ;
16028
16029 if (!args) SWIG_fail;
16030 swig_obj[0] = args;
16031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16034 }
16035 arg1 = reinterpret_cast< wxImage * >(argp1);
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 (arg1)->Destroy();
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 resultobj = SWIG_Py_Void();
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj = 0;
16051 wxImage *arg1 = (wxImage *) 0 ;
16052 int arg2 ;
16053 int arg3 ;
16054 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16055 SwigValueWrapper<wxImage > result;
16056 void *argp1 = 0 ;
16057 int res1 = 0 ;
16058 int val2 ;
16059 int ecode2 = 0 ;
16060 int val3 ;
16061 int ecode3 = 0 ;
16062 int val4 ;
16063 int ecode4 = 0 ;
16064 PyObject * obj0 = 0 ;
16065 PyObject * obj1 = 0 ;
16066 PyObject * obj2 = 0 ;
16067 PyObject * obj3 = 0 ;
16068 char * kwnames[] = {
16069 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16070 };
16071
16072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16074 if (!SWIG_IsOK(res1)) {
16075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16076 }
16077 arg1 = reinterpret_cast< wxImage * >(argp1);
16078 ecode2 = SWIG_AsVal_int(obj1, &val2);
16079 if (!SWIG_IsOK(ecode2)) {
16080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16081 }
16082 arg2 = static_cast< int >(val2);
16083 ecode3 = SWIG_AsVal_int(obj2, &val3);
16084 if (!SWIG_IsOK(ecode3)) {
16085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16086 }
16087 arg3 = static_cast< int >(val3);
16088 if (obj3) {
16089 ecode4 = SWIG_AsVal_int(obj3, &val4);
16090 if (!SWIG_IsOK(ecode4)) {
16091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16092 }
16093 arg4 = static_cast< int >(val4);
16094 }
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (arg1)->Scale(arg2,arg3,arg4);
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxImage *arg1 = (wxImage *) 0 ;
16111 int arg2 ;
16112 int arg3 ;
16113 SwigValueWrapper<wxImage > result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 int val2 ;
16117 int ecode2 = 0 ;
16118 int val3 ;
16119 int ecode3 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 PyObject * obj2 = 0 ;
16123 char * kwnames[] = {
16124 (char *) "self",(char *) "width",(char *) "height", NULL
16125 };
16126
16127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16129 if (!SWIG_IsOK(res1)) {
16130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16131 }
16132 arg1 = reinterpret_cast< wxImage * >(argp1);
16133 ecode2 = SWIG_AsVal_int(obj1, &val2);
16134 if (!SWIG_IsOK(ecode2)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16136 }
16137 arg2 = static_cast< int >(val2);
16138 ecode3 = SWIG_AsVal_int(obj2, &val3);
16139 if (!SWIG_IsOK(ecode3)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16141 }
16142 arg3 = static_cast< int >(val3);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = 0;
16158 wxImage *arg1 = (wxImage *) 0 ;
16159 int arg2 ;
16160 int arg3 ;
16161 SwigValueWrapper<wxImage > result;
16162 void *argp1 = 0 ;
16163 int res1 = 0 ;
16164 int val2 ;
16165 int ecode2 = 0 ;
16166 int val3 ;
16167 int ecode3 = 0 ;
16168 PyObject * obj0 = 0 ;
16169 PyObject * obj1 = 0 ;
16170 PyObject * obj2 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "width",(char *) "height", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 ecode2 = SWIG_AsVal_int(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16184 }
16185 arg2 = static_cast< int >(val2);
16186 ecode3 = SWIG_AsVal_int(obj2, &val3);
16187 if (!SWIG_IsOK(ecode3)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16189 }
16190 arg3 = static_cast< int >(val3);
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 int arg2 ;
16208 SwigValueWrapper<wxImage > result;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 int val2 ;
16212 int ecode2 = 0 ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *) "radius", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16223 }
16224 arg1 = reinterpret_cast< wxImage * >(argp1);
16225 ecode2 = SWIG_AsVal_int(obj1, &val2);
16226 if (!SWIG_IsOK(ecode2)) {
16227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16228 }
16229 arg2 = static_cast< int >(val2);
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 result = (arg1)->Blur(arg2);
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj = 0;
16245 wxImage *arg1 = (wxImage *) 0 ;
16246 int arg2 ;
16247 SwigValueWrapper<wxImage > result;
16248 void *argp1 = 0 ;
16249 int res1 = 0 ;
16250 int val2 ;
16251 int ecode2 = 0 ;
16252 PyObject * obj0 = 0 ;
16253 PyObject * obj1 = 0 ;
16254 char * kwnames[] = {
16255 (char *) "self",(char *) "radius", NULL
16256 };
16257
16258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16260 if (!SWIG_IsOK(res1)) {
16261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16262 }
16263 arg1 = reinterpret_cast< wxImage * >(argp1);
16264 ecode2 = SWIG_AsVal_int(obj1, &val2);
16265 if (!SWIG_IsOK(ecode2)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16267 }
16268 arg2 = static_cast< int >(val2);
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (arg1)->BlurHorizontal(arg2);
16272 wxPyEndAllowThreads(__tstate);
16273 if (PyErr_Occurred()) SWIG_fail;
16274 }
16275 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16276 return resultobj;
16277 fail:
16278 return NULL;
16279 }
16280
16281
16282 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16283 PyObject *resultobj = 0;
16284 wxImage *arg1 = (wxImage *) 0 ;
16285 int arg2 ;
16286 SwigValueWrapper<wxImage > result;
16287 void *argp1 = 0 ;
16288 int res1 = 0 ;
16289 int val2 ;
16290 int ecode2 = 0 ;
16291 PyObject * obj0 = 0 ;
16292 PyObject * obj1 = 0 ;
16293 char * kwnames[] = {
16294 (char *) "self",(char *) "radius", NULL
16295 };
16296
16297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16299 if (!SWIG_IsOK(res1)) {
16300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16301 }
16302 arg1 = reinterpret_cast< wxImage * >(argp1);
16303 ecode2 = SWIG_AsVal_int(obj1, &val2);
16304 if (!SWIG_IsOK(ecode2)) {
16305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16306 }
16307 arg2 = static_cast< int >(val2);
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 result = (arg1)->BlurVertical(arg2);
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16315 return resultobj;
16316 fail:
16317 return NULL;
16318 }
16319
16320
16321 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16322 PyObject *resultobj = 0;
16323 wxImage *arg1 = (wxImage *) 0 ;
16324 int arg2 ;
16325 int arg3 ;
16326 SwigValueWrapper<wxImage > result;
16327 void *argp1 = 0 ;
16328 int res1 = 0 ;
16329 int val2 ;
16330 int ecode2 = 0 ;
16331 int val3 ;
16332 int ecode3 = 0 ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 PyObject * obj2 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16344 }
16345 arg1 = reinterpret_cast< wxImage * >(argp1);
16346 ecode2 = SWIG_AsVal_int(obj1, &val2);
16347 if (!SWIG_IsOK(ecode2)) {
16348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16349 }
16350 arg2 = static_cast< int >(val2);
16351 ecode3 = SWIG_AsVal_int(obj2, &val3);
16352 if (!SWIG_IsOK(ecode3)) {
16353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16354 }
16355 arg3 = static_cast< int >(val3);
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj = 0;
16371 wxImage *arg1 = (wxImage *) 0 ;
16372 int arg2 ;
16373 int arg3 ;
16374 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16375 wxImage *result = 0 ;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 int val2 ;
16379 int ecode2 = 0 ;
16380 int val3 ;
16381 int ecode3 = 0 ;
16382 int val4 ;
16383 int ecode4 = 0 ;
16384 PyObject * obj0 = 0 ;
16385 PyObject * obj1 = 0 ;
16386 PyObject * obj2 = 0 ;
16387 PyObject * obj3 = 0 ;
16388 char * kwnames[] = {
16389 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16390 };
16391
16392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16394 if (!SWIG_IsOK(res1)) {
16395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16396 }
16397 arg1 = reinterpret_cast< wxImage * >(argp1);
16398 ecode2 = SWIG_AsVal_int(obj1, &val2);
16399 if (!SWIG_IsOK(ecode2)) {
16400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16401 }
16402 arg2 = static_cast< int >(val2);
16403 ecode3 = SWIG_AsVal_int(obj2, &val3);
16404 if (!SWIG_IsOK(ecode3)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16406 }
16407 arg3 = static_cast< int >(val3);
16408 if (obj3) {
16409 ecode4 = SWIG_AsVal_int(obj3, &val4);
16410 if (!SWIG_IsOK(ecode4)) {
16411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16412 }
16413 arg4 = static_cast< int >(val4);
16414 }
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 {
16418 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16419 result = (wxImage *) &_result_ref;
16420 }
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj = 0;
16433 wxImage *arg1 = (wxImage *) 0 ;
16434 wxSize *arg2 = 0 ;
16435 wxPoint *arg3 = 0 ;
16436 int arg4 = (int) -1 ;
16437 int arg5 = (int) -1 ;
16438 int arg6 = (int) -1 ;
16439 wxImage *result = 0 ;
16440 void *argp1 = 0 ;
16441 int res1 = 0 ;
16442 wxSize temp2 ;
16443 wxPoint temp3 ;
16444 int val4 ;
16445 int ecode4 = 0 ;
16446 int val5 ;
16447 int ecode5 = 0 ;
16448 int val6 ;
16449 int ecode6 = 0 ;
16450 PyObject * obj0 = 0 ;
16451 PyObject * obj1 = 0 ;
16452 PyObject * obj2 = 0 ;
16453 PyObject * obj3 = 0 ;
16454 PyObject * obj4 = 0 ;
16455 PyObject * obj5 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16462 if (!SWIG_IsOK(res1)) {
16463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16464 }
16465 arg1 = reinterpret_cast< wxImage * >(argp1);
16466 {
16467 arg2 = &temp2;
16468 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16469 }
16470 {
16471 arg3 = &temp3;
16472 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16473 }
16474 if (obj3) {
16475 ecode4 = SWIG_AsVal_int(obj3, &val4);
16476 if (!SWIG_IsOK(ecode4)) {
16477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16478 }
16479 arg4 = static_cast< int >(val4);
16480 }
16481 if (obj4) {
16482 ecode5 = SWIG_AsVal_int(obj4, &val5);
16483 if (!SWIG_IsOK(ecode5)) {
16484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16485 }
16486 arg5 = static_cast< int >(val5);
16487 }
16488 if (obj5) {
16489 ecode6 = SWIG_AsVal_int(obj5, &val6);
16490 if (!SWIG_IsOK(ecode6)) {
16491 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16492 }
16493 arg6 = static_cast< int >(val6);
16494 }
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 {
16498 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16499 result = (wxImage *) &_result_ref;
16500 }
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj = 0;
16513 wxImage *arg1 = (wxImage *) 0 ;
16514 int arg2 ;
16515 int arg3 ;
16516 byte arg4 ;
16517 byte arg5 ;
16518 byte arg6 ;
16519 void *argp1 = 0 ;
16520 int res1 = 0 ;
16521 int val2 ;
16522 int ecode2 = 0 ;
16523 int val3 ;
16524 int ecode3 = 0 ;
16525 unsigned char val4 ;
16526 int ecode4 = 0 ;
16527 unsigned char val5 ;
16528 int ecode5 = 0 ;
16529 unsigned char val6 ;
16530 int ecode6 = 0 ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 PyObject * obj2 = 0 ;
16534 PyObject * obj3 = 0 ;
16535 PyObject * obj4 = 0 ;
16536 PyObject * obj5 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16543 if (!SWIG_IsOK(res1)) {
16544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16545 }
16546 arg1 = reinterpret_cast< wxImage * >(argp1);
16547 ecode2 = SWIG_AsVal_int(obj1, &val2);
16548 if (!SWIG_IsOK(ecode2)) {
16549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16550 }
16551 arg2 = static_cast< int >(val2);
16552 ecode3 = SWIG_AsVal_int(obj2, &val3);
16553 if (!SWIG_IsOK(ecode3)) {
16554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16555 }
16556 arg3 = static_cast< int >(val3);
16557 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16558 if (!SWIG_IsOK(ecode4)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16560 }
16561 arg4 = static_cast< byte >(val4);
16562 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16563 if (!SWIG_IsOK(ecode5)) {
16564 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16565 }
16566 arg5 = static_cast< byte >(val5);
16567 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16568 if (!SWIG_IsOK(ecode6)) {
16569 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16570 }
16571 arg6 = static_cast< byte >(val6);
16572 {
16573 PyThreadState* __tstate = wxPyBeginAllowThreads();
16574 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 resultobj = SWIG_Py_Void();
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj = 0;
16587 wxImage *arg1 = (wxImage *) 0 ;
16588 wxRect *arg2 = 0 ;
16589 byte arg3 ;
16590 byte arg4 ;
16591 byte arg5 ;
16592 void *argp1 = 0 ;
16593 int res1 = 0 ;
16594 wxRect temp2 ;
16595 unsigned char val3 ;
16596 int ecode3 = 0 ;
16597 unsigned char val4 ;
16598 int ecode4 = 0 ;
16599 unsigned char val5 ;
16600 int ecode5 = 0 ;
16601 PyObject * obj0 = 0 ;
16602 PyObject * obj1 = 0 ;
16603 PyObject * obj2 = 0 ;
16604 PyObject * obj3 = 0 ;
16605 PyObject * obj4 = 0 ;
16606 char * kwnames[] = {
16607 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16608 };
16609
16610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16614 }
16615 arg1 = reinterpret_cast< wxImage * >(argp1);
16616 {
16617 arg2 = &temp2;
16618 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16619 }
16620 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16621 if (!SWIG_IsOK(ecode3)) {
16622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16623 }
16624 arg3 = static_cast< byte >(val3);
16625 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16626 if (!SWIG_IsOK(ecode4)) {
16627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16628 }
16629 arg4 = static_cast< byte >(val4);
16630 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16631 if (!SWIG_IsOK(ecode5)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16633 }
16634 arg5 = static_cast< byte >(val5);
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 resultobj = SWIG_Py_Void();
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16649 PyObject *resultobj = 0;
16650 wxImage *arg1 = (wxImage *) 0 ;
16651 int arg2 ;
16652 int arg3 ;
16653 byte result;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 int val2 ;
16657 int ecode2 = 0 ;
16658 int val3 ;
16659 int ecode3 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "self",(char *) "x",(char *) "y", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16671 }
16672 arg1 = reinterpret_cast< wxImage * >(argp1);
16673 ecode2 = SWIG_AsVal_int(obj1, &val2);
16674 if (!SWIG_IsOK(ecode2)) {
16675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16676 }
16677 arg2 = static_cast< int >(val2);
16678 ecode3 = SWIG_AsVal_int(obj2, &val3);
16679 if (!SWIG_IsOK(ecode3)) {
16680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16681 }
16682 arg3 = static_cast< int >(val3);
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = (byte)(arg1)->GetRed(arg2,arg3);
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj = 0;
16698 wxImage *arg1 = (wxImage *) 0 ;
16699 int arg2 ;
16700 int arg3 ;
16701 byte result;
16702 void *argp1 = 0 ;
16703 int res1 = 0 ;
16704 int val2 ;
16705 int ecode2 = 0 ;
16706 int val3 ;
16707 int ecode3 = 0 ;
16708 PyObject * obj0 = 0 ;
16709 PyObject * obj1 = 0 ;
16710 PyObject * obj2 = 0 ;
16711 char * kwnames[] = {
16712 (char *) "self",(char *) "x",(char *) "y", NULL
16713 };
16714
16715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16717 if (!SWIG_IsOK(res1)) {
16718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16719 }
16720 arg1 = reinterpret_cast< wxImage * >(argp1);
16721 ecode2 = SWIG_AsVal_int(obj1, &val2);
16722 if (!SWIG_IsOK(ecode2)) {
16723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16724 }
16725 arg2 = static_cast< int >(val2);
16726 ecode3 = SWIG_AsVal_int(obj2, &val3);
16727 if (!SWIG_IsOK(ecode3)) {
16728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16729 }
16730 arg3 = static_cast< int >(val3);
16731 {
16732 PyThreadState* __tstate = wxPyBeginAllowThreads();
16733 result = (byte)(arg1)->GetGreen(arg2,arg3);
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj = 0;
16746 wxImage *arg1 = (wxImage *) 0 ;
16747 int arg2 ;
16748 int arg3 ;
16749 byte result;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 int val2 ;
16753 int ecode2 = 0 ;
16754 int val3 ;
16755 int ecode3 = 0 ;
16756 PyObject * obj0 = 0 ;
16757 PyObject * obj1 = 0 ;
16758 PyObject * obj2 = 0 ;
16759 char * kwnames[] = {
16760 (char *) "self",(char *) "x",(char *) "y", NULL
16761 };
16762
16763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16767 }
16768 arg1 = reinterpret_cast< wxImage * >(argp1);
16769 ecode2 = SWIG_AsVal_int(obj1, &val2);
16770 if (!SWIG_IsOK(ecode2)) {
16771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16772 }
16773 arg2 = static_cast< int >(val2);
16774 ecode3 = SWIG_AsVal_int(obj2, &val3);
16775 if (!SWIG_IsOK(ecode3)) {
16776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16777 }
16778 arg3 = static_cast< int >(val3);
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 result = (byte)(arg1)->GetBlue(arg2,arg3);
16782 wxPyEndAllowThreads(__tstate);
16783 if (PyErr_Occurred()) SWIG_fail;
16784 }
16785 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16786 return resultobj;
16787 fail:
16788 return NULL;
16789 }
16790
16791
16792 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16793 PyObject *resultobj = 0;
16794 wxImage *arg1 = (wxImage *) 0 ;
16795 int arg2 ;
16796 int arg3 ;
16797 byte arg4 ;
16798 void *argp1 = 0 ;
16799 int res1 = 0 ;
16800 int val2 ;
16801 int ecode2 = 0 ;
16802 int val3 ;
16803 int ecode3 = 0 ;
16804 unsigned char val4 ;
16805 int ecode4 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 PyObject * obj1 = 0 ;
16808 PyObject * obj2 = 0 ;
16809 PyObject * obj3 = 0 ;
16810 char * kwnames[] = {
16811 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16812 };
16813
16814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16816 if (!SWIG_IsOK(res1)) {
16817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16818 }
16819 arg1 = reinterpret_cast< wxImage * >(argp1);
16820 ecode2 = SWIG_AsVal_int(obj1, &val2);
16821 if (!SWIG_IsOK(ecode2)) {
16822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16823 }
16824 arg2 = static_cast< int >(val2);
16825 ecode3 = SWIG_AsVal_int(obj2, &val3);
16826 if (!SWIG_IsOK(ecode3)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16828 }
16829 arg3 = static_cast< int >(val3);
16830 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16831 if (!SWIG_IsOK(ecode4)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16833 }
16834 arg4 = static_cast< byte >(val4);
16835 {
16836 PyThreadState* __tstate = wxPyBeginAllowThreads();
16837 (arg1)->SetAlpha(arg2,arg3,arg4);
16838 wxPyEndAllowThreads(__tstate);
16839 if (PyErr_Occurred()) SWIG_fail;
16840 }
16841 resultobj = SWIG_Py_Void();
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj = 0;
16850 wxImage *arg1 = (wxImage *) 0 ;
16851 int arg2 ;
16852 int arg3 ;
16853 byte result;
16854 void *argp1 = 0 ;
16855 int res1 = 0 ;
16856 int val2 ;
16857 int ecode2 = 0 ;
16858 int val3 ;
16859 int ecode3 = 0 ;
16860 PyObject * obj0 = 0 ;
16861 PyObject * obj1 = 0 ;
16862 PyObject * obj2 = 0 ;
16863 char * kwnames[] = {
16864 (char *) "self",(char *) "x",(char *) "y", NULL
16865 };
16866
16867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16869 if (!SWIG_IsOK(res1)) {
16870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16871 }
16872 arg1 = reinterpret_cast< wxImage * >(argp1);
16873 ecode2 = SWIG_AsVal_int(obj1, &val2);
16874 if (!SWIG_IsOK(ecode2)) {
16875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16876 }
16877 arg2 = static_cast< int >(val2);
16878 ecode3 = SWIG_AsVal_int(obj2, &val3);
16879 if (!SWIG_IsOK(ecode3)) {
16880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16881 }
16882 arg3 = static_cast< int >(val3);
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16886 wxPyEndAllowThreads(__tstate);
16887 if (PyErr_Occurred()) SWIG_fail;
16888 }
16889 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16890 return resultobj;
16891 fail:
16892 return NULL;
16893 }
16894
16895
16896 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16897 PyObject *resultobj = 0;
16898 wxImage *arg1 = (wxImage *) 0 ;
16899 bool result;
16900 void *argp1 = 0 ;
16901 int res1 = 0 ;
16902 PyObject *swig_obj[1] ;
16903
16904 if (!args) SWIG_fail;
16905 swig_obj[0] = args;
16906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16909 }
16910 arg1 = reinterpret_cast< wxImage * >(argp1);
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = (bool)(arg1)->HasAlpha();
16914 wxPyEndAllowThreads(__tstate);
16915 if (PyErr_Occurred()) SWIG_fail;
16916 }
16917 {
16918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16919 }
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16927 PyObject *resultobj = 0;
16928 wxImage *arg1 = (wxImage *) 0 ;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 PyObject *swig_obj[1] ;
16932
16933 if (!args) SWIG_fail;
16934 swig_obj[0] = args;
16935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16936 if (!SWIG_IsOK(res1)) {
16937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16938 }
16939 arg1 = reinterpret_cast< wxImage * >(argp1);
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 (arg1)->InitAlpha();
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 resultobj = SWIG_Py_Void();
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj = 0;
16955 wxImage *arg1 = (wxImage *) 0 ;
16956 int arg2 ;
16957 int arg3 ;
16958 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16959 bool result;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 int val2 ;
16963 int ecode2 = 0 ;
16964 int val3 ;
16965 int ecode3 = 0 ;
16966 unsigned char val4 ;
16967 int ecode4 = 0 ;
16968 PyObject * obj0 = 0 ;
16969 PyObject * obj1 = 0 ;
16970 PyObject * obj2 = 0 ;
16971 PyObject * obj3 = 0 ;
16972 char * kwnames[] = {
16973 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16974 };
16975
16976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16980 }
16981 arg1 = reinterpret_cast< wxImage * >(argp1);
16982 ecode2 = SWIG_AsVal_int(obj1, &val2);
16983 if (!SWIG_IsOK(ecode2)) {
16984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16985 }
16986 arg2 = static_cast< int >(val2);
16987 ecode3 = SWIG_AsVal_int(obj2, &val3);
16988 if (!SWIG_IsOK(ecode3)) {
16989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16990 }
16991 arg3 = static_cast< int >(val3);
16992 if (obj3) {
16993 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16994 if (!SWIG_IsOK(ecode4)) {
16995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16996 }
16997 arg4 = static_cast< byte >(val4);
16998 }
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj = 0;
17016 wxImage *arg1 = (wxImage *) 0 ;
17017 byte *arg2 = (byte *) 0 ;
17018 byte *arg3 = (byte *) 0 ;
17019 byte *arg4 = (byte *) 0 ;
17020 byte arg5 = (byte) 0 ;
17021 byte arg6 = (byte) 0 ;
17022 byte arg7 = (byte) 0 ;
17023 bool result;
17024 void *argp1 = 0 ;
17025 int res1 = 0 ;
17026 byte temp2 ;
17027 int res2 = SWIG_TMPOBJ ;
17028 byte temp3 ;
17029 int res3 = SWIG_TMPOBJ ;
17030 byte temp4 ;
17031 int res4 = SWIG_TMPOBJ ;
17032 unsigned char val5 ;
17033 int ecode5 = 0 ;
17034 unsigned char val6 ;
17035 int ecode6 = 0 ;
17036 unsigned char val7 ;
17037 int ecode7 = 0 ;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 PyObject * obj2 = 0 ;
17041 PyObject * obj3 = 0 ;
17042 char * kwnames[] = {
17043 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17044 };
17045
17046 arg2 = &temp2;
17047 arg3 = &temp3;
17048 arg4 = &temp4;
17049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17051 if (!SWIG_IsOK(res1)) {
17052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17053 }
17054 arg1 = reinterpret_cast< wxImage * >(argp1);
17055 if (obj1) {
17056 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17057 if (!SWIG_IsOK(ecode5)) {
17058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17059 }
17060 arg5 = static_cast< byte >(val5);
17061 }
17062 if (obj2) {
17063 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17064 if (!SWIG_IsOK(ecode6)) {
17065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17066 }
17067 arg6 = static_cast< byte >(val6);
17068 }
17069 if (obj3) {
17070 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17071 if (!SWIG_IsOK(ecode7)) {
17072 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17073 }
17074 arg7 = static_cast< byte >(val7);
17075 }
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 {
17083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17084 }
17085 if (SWIG_IsTmpObj(res2)) {
17086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17087 } else {
17088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17090 }
17091 if (SWIG_IsTmpObj(res3)) {
17092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17093 } else {
17094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17096 }
17097 if (SWIG_IsTmpObj(res4)) {
17098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17099 } else {
17100 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj = 0;
17111 wxImage *arg1 = (wxImage *) 0 ;
17112 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17113 bool result;
17114 void *argp1 = 0 ;
17115 int res1 = 0 ;
17116 unsigned char val2 ;
17117 int ecode2 = 0 ;
17118 PyObject * obj0 = 0 ;
17119 PyObject * obj1 = 0 ;
17120 char * kwnames[] = {
17121 (char *) "self",(char *) "threshold", NULL
17122 };
17123
17124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17126 if (!SWIG_IsOK(res1)) {
17127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17128 }
17129 arg1 = reinterpret_cast< wxImage * >(argp1);
17130 if (obj1) {
17131 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17132 if (!SWIG_IsOK(ecode2)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17134 }
17135 arg2 = static_cast< byte >(val2);
17136 }
17137 {
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 {
17144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17145 }
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj = 0;
17154 wxImage *arg1 = (wxImage *) 0 ;
17155 byte arg2 ;
17156 byte arg3 ;
17157 byte arg4 ;
17158 bool result;
17159 void *argp1 = 0 ;
17160 int res1 = 0 ;
17161 unsigned char val2 ;
17162 int ecode2 = 0 ;
17163 unsigned char val3 ;
17164 int ecode3 = 0 ;
17165 unsigned char val4 ;
17166 int ecode4 = 0 ;
17167 PyObject * obj0 = 0 ;
17168 PyObject * obj1 = 0 ;
17169 PyObject * obj2 = 0 ;
17170 PyObject * obj3 = 0 ;
17171 char * kwnames[] = {
17172 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17173 };
17174
17175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17177 if (!SWIG_IsOK(res1)) {
17178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17179 }
17180 arg1 = reinterpret_cast< wxImage * >(argp1);
17181 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17182 if (!SWIG_IsOK(ecode2)) {
17183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17184 }
17185 arg2 = static_cast< byte >(val2);
17186 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17187 if (!SWIG_IsOK(ecode3)) {
17188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17189 }
17190 arg3 = static_cast< byte >(val3);
17191 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17192 if (!SWIG_IsOK(ecode4)) {
17193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17194 }
17195 arg4 = static_cast< byte >(val4);
17196 {
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17199 wxPyEndAllowThreads(__tstate);
17200 if (PyErr_Occurred()) SWIG_fail;
17201 }
17202 {
17203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17204 }
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17212 PyObject *resultobj = 0;
17213 wxImage *arg1 = (wxImage *) 0 ;
17214 wxImage *arg2 = 0 ;
17215 byte arg3 ;
17216 byte arg4 ;
17217 byte arg5 ;
17218 bool result;
17219 void *argp1 = 0 ;
17220 int res1 = 0 ;
17221 void *argp2 = 0 ;
17222 int res2 = 0 ;
17223 unsigned char val3 ;
17224 int ecode3 = 0 ;
17225 unsigned char val4 ;
17226 int ecode4 = 0 ;
17227 unsigned char val5 ;
17228 int ecode5 = 0 ;
17229 PyObject * obj0 = 0 ;
17230 PyObject * obj1 = 0 ;
17231 PyObject * obj2 = 0 ;
17232 PyObject * obj3 = 0 ;
17233 PyObject * obj4 = 0 ;
17234 char * kwnames[] = {
17235 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17236 };
17237
17238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17240 if (!SWIG_IsOK(res1)) {
17241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17242 }
17243 arg1 = reinterpret_cast< wxImage * >(argp1);
17244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17245 if (!SWIG_IsOK(res2)) {
17246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17247 }
17248 if (!argp2) {
17249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17250 }
17251 arg2 = reinterpret_cast< wxImage * >(argp2);
17252 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17253 if (!SWIG_IsOK(ecode3)) {
17254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17255 }
17256 arg3 = static_cast< byte >(val3);
17257 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17258 if (!SWIG_IsOK(ecode4)) {
17259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17260 }
17261 arg4 = static_cast< byte >(val4);
17262 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17263 if (!SWIG_IsOK(ecode5)) {
17264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17265 }
17266 arg5 = static_cast< byte >(val5);
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj = 0;
17284 wxString *arg1 = 0 ;
17285 bool result;
17286 bool temp1 = false ;
17287 PyObject * obj0 = 0 ;
17288 char * kwnames[] = {
17289 (char *) "filename", NULL
17290 };
17291
17292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17293 {
17294 arg1 = wxString_in_helper(obj0);
17295 if (arg1 == NULL) SWIG_fail;
17296 temp1 = true;
17297 }
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 {
17305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17306 }
17307 {
17308 if (temp1)
17309 delete arg1;
17310 }
17311 return resultobj;
17312 fail:
17313 {
17314 if (temp1)
17315 delete arg1;
17316 }
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17322 PyObject *resultobj = 0;
17323 wxString *arg1 = 0 ;
17324 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17325 int result;
17326 bool temp1 = false ;
17327 long val2 ;
17328 int ecode2 = 0 ;
17329 PyObject * obj0 = 0 ;
17330 PyObject * obj1 = 0 ;
17331 char * kwnames[] = {
17332 (char *) "filename",(char *) "type", NULL
17333 };
17334
17335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17336 {
17337 arg1 = wxString_in_helper(obj0);
17338 if (arg1 == NULL) SWIG_fail;
17339 temp1 = true;
17340 }
17341 if (obj1) {
17342 ecode2 = SWIG_AsVal_long(obj1, &val2);
17343 if (!SWIG_IsOK(ecode2)) {
17344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17345 }
17346 arg2 = static_cast< long >(val2);
17347 }
17348 {
17349 PyThreadState* __tstate = wxPyBeginAllowThreads();
17350 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 resultobj = SWIG_From_int(static_cast< int >(result));
17355 {
17356 if (temp1)
17357 delete arg1;
17358 }
17359 return resultobj;
17360 fail:
17361 {
17362 if (temp1)
17363 delete arg1;
17364 }
17365 return NULL;
17366 }
17367
17368
17369 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj = 0;
17371 wxImage *arg1 = (wxImage *) 0 ;
17372 wxString *arg2 = 0 ;
17373 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17374 int arg4 = (int) -1 ;
17375 bool result;
17376 void *argp1 = 0 ;
17377 int res1 = 0 ;
17378 bool temp2 = false ;
17379 long val3 ;
17380 int ecode3 = 0 ;
17381 int val4 ;
17382 int ecode4 = 0 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 PyObject * obj2 = 0 ;
17386 PyObject * obj3 = 0 ;
17387 char * kwnames[] = {
17388 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17389 };
17390
17391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17393 if (!SWIG_IsOK(res1)) {
17394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17395 }
17396 arg1 = reinterpret_cast< wxImage * >(argp1);
17397 {
17398 arg2 = wxString_in_helper(obj1);
17399 if (arg2 == NULL) SWIG_fail;
17400 temp2 = true;
17401 }
17402 if (obj2) {
17403 ecode3 = SWIG_AsVal_long(obj2, &val3);
17404 if (!SWIG_IsOK(ecode3)) {
17405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17406 }
17407 arg3 = static_cast< long >(val3);
17408 }
17409 if (obj3) {
17410 ecode4 = SWIG_AsVal_int(obj3, &val4);
17411 if (!SWIG_IsOK(ecode4)) {
17412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17413 }
17414 arg4 = static_cast< int >(val4);
17415 }
17416 {
17417 PyThreadState* __tstate = wxPyBeginAllowThreads();
17418 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17419 wxPyEndAllowThreads(__tstate);
17420 if (PyErr_Occurred()) SWIG_fail;
17421 }
17422 {
17423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17424 }
17425 {
17426 if (temp2)
17427 delete arg2;
17428 }
17429 return resultobj;
17430 fail:
17431 {
17432 if (temp2)
17433 delete arg2;
17434 }
17435 return NULL;
17436 }
17437
17438
17439 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj = 0;
17441 wxImage *arg1 = (wxImage *) 0 ;
17442 wxString *arg2 = 0 ;
17443 wxString *arg3 = 0 ;
17444 int arg4 = (int) -1 ;
17445 bool result;
17446 void *argp1 = 0 ;
17447 int res1 = 0 ;
17448 bool temp2 = false ;
17449 bool temp3 = false ;
17450 int val4 ;
17451 int ecode4 = 0 ;
17452 PyObject * obj0 = 0 ;
17453 PyObject * obj1 = 0 ;
17454 PyObject * obj2 = 0 ;
17455 PyObject * obj3 = 0 ;
17456 char * kwnames[] = {
17457 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17458 };
17459
17460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17462 if (!SWIG_IsOK(res1)) {
17463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17464 }
17465 arg1 = reinterpret_cast< wxImage * >(argp1);
17466 {
17467 arg2 = wxString_in_helper(obj1);
17468 if (arg2 == NULL) SWIG_fail;
17469 temp2 = true;
17470 }
17471 {
17472 arg3 = wxString_in_helper(obj2);
17473 if (arg3 == NULL) SWIG_fail;
17474 temp3 = true;
17475 }
17476 if (obj3) {
17477 ecode4 = SWIG_AsVal_int(obj3, &val4);
17478 if (!SWIG_IsOK(ecode4)) {
17479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17480 }
17481 arg4 = static_cast< int >(val4);
17482 }
17483 {
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 {
17490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17491 }
17492 {
17493 if (temp2)
17494 delete arg2;
17495 }
17496 {
17497 if (temp3)
17498 delete arg3;
17499 }
17500 return resultobj;
17501 fail:
17502 {
17503 if (temp2)
17504 delete arg2;
17505 }
17506 {
17507 if (temp3)
17508 delete arg3;
17509 }
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj = 0;
17516 wxImage *arg1 = (wxImage *) 0 ;
17517 wxString *arg2 = 0 ;
17518 int arg3 ;
17519 bool result;
17520 void *argp1 = 0 ;
17521 int res1 = 0 ;
17522 bool temp2 = false ;
17523 int val3 ;
17524 int ecode3 = 0 ;
17525 PyObject * obj0 = 0 ;
17526 PyObject * obj1 = 0 ;
17527 PyObject * obj2 = 0 ;
17528 char * kwnames[] = {
17529 (char *) "self",(char *) "name",(char *) "type", NULL
17530 };
17531
17532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17534 if (!SWIG_IsOK(res1)) {
17535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17536 }
17537 arg1 = reinterpret_cast< wxImage * >(argp1);
17538 {
17539 arg2 = wxString_in_helper(obj1);
17540 if (arg2 == NULL) SWIG_fail;
17541 temp2 = true;
17542 }
17543 ecode3 = SWIG_AsVal_int(obj2, &val3);
17544 if (!SWIG_IsOK(ecode3)) {
17545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17546 }
17547 arg3 = static_cast< int >(val3);
17548 {
17549 PyThreadState* __tstate = wxPyBeginAllowThreads();
17550 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 {
17555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17556 }
17557 {
17558 if (temp2)
17559 delete arg2;
17560 }
17561 return resultobj;
17562 fail:
17563 {
17564 if (temp2)
17565 delete arg2;
17566 }
17567 return NULL;
17568 }
17569
17570
17571 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = 0;
17573 wxImage *arg1 = (wxImage *) 0 ;
17574 wxString *arg2 = 0 ;
17575 wxString *arg3 = 0 ;
17576 bool result;
17577 void *argp1 = 0 ;
17578 int res1 = 0 ;
17579 bool temp2 = false ;
17580 bool temp3 = false ;
17581 PyObject * obj0 = 0 ;
17582 PyObject * obj1 = 0 ;
17583 PyObject * obj2 = 0 ;
17584 char * kwnames[] = {
17585 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17586 };
17587
17588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17592 }
17593 arg1 = reinterpret_cast< wxImage * >(argp1);
17594 {
17595 arg2 = wxString_in_helper(obj1);
17596 if (arg2 == NULL) SWIG_fail;
17597 temp2 = true;
17598 }
17599 {
17600 arg3 = wxString_in_helper(obj2);
17601 if (arg3 == NULL) SWIG_fail;
17602 temp3 = true;
17603 }
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 {
17611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17612 }
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 {
17618 if (temp3)
17619 delete arg3;
17620 }
17621 return resultobj;
17622 fail:
17623 {
17624 if (temp2)
17625 delete arg2;
17626 }
17627 {
17628 if (temp3)
17629 delete arg3;
17630 }
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17636 PyObject *resultobj = 0;
17637 wxInputStream *arg1 = 0 ;
17638 bool result;
17639 wxPyInputStream *temp1 ;
17640 bool created1 ;
17641 PyObject * obj0 = 0 ;
17642 char * kwnames[] = {
17643 (char *) "stream", NULL
17644 };
17645
17646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17647 {
17648 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17649 arg1 = temp1->m_wxis;
17650 created1 = false;
17651 } else {
17652 PyErr_Clear(); // clear the failure of the wxPyConvert above
17653 arg1 = wxPyCBInputStream_create(obj0, false);
17654 if (arg1 == NULL) {
17655 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17656 SWIG_fail;
17657 }
17658 created1 = true;
17659 }
17660 }
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (bool)wxImage::CanRead(*arg1);
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 {
17668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17669 }
17670 {
17671 if (created1) delete arg1;
17672 }
17673 return resultobj;
17674 fail:
17675 {
17676 if (created1) delete arg1;
17677 }
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17683 PyObject *resultobj = 0;
17684 wxImage *arg1 = (wxImage *) 0 ;
17685 wxInputStream *arg2 = 0 ;
17686 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17687 int arg4 = (int) -1 ;
17688 bool result;
17689 void *argp1 = 0 ;
17690 int res1 = 0 ;
17691 wxPyInputStream *temp2 ;
17692 bool created2 ;
17693 long val3 ;
17694 int ecode3 = 0 ;
17695 int val4 ;
17696 int ecode4 = 0 ;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 PyObject * obj2 = 0 ;
17700 PyObject * obj3 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17707 if (!SWIG_IsOK(res1)) {
17708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17709 }
17710 arg1 = reinterpret_cast< wxImage * >(argp1);
17711 {
17712 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17713 arg2 = temp2->m_wxis;
17714 created2 = false;
17715 } else {
17716 PyErr_Clear(); // clear the failure of the wxPyConvert above
17717 arg2 = wxPyCBInputStream_create(obj1, false);
17718 if (arg2 == NULL) {
17719 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17720 SWIG_fail;
17721 }
17722 created2 = true;
17723 }
17724 }
17725 if (obj2) {
17726 ecode3 = SWIG_AsVal_long(obj2, &val3);
17727 if (!SWIG_IsOK(ecode3)) {
17728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17729 }
17730 arg3 = static_cast< long >(val3);
17731 }
17732 if (obj3) {
17733 ecode4 = SWIG_AsVal_int(obj3, &val4);
17734 if (!SWIG_IsOK(ecode4)) {
17735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17736 }
17737 arg4 = static_cast< int >(val4);
17738 }
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 {
17746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17747 }
17748 {
17749 if (created2) delete arg2;
17750 }
17751 return resultobj;
17752 fail:
17753 {
17754 if (created2) delete arg2;
17755 }
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = 0;
17762 wxImage *arg1 = (wxImage *) 0 ;
17763 wxInputStream *arg2 = 0 ;
17764 wxString *arg3 = 0 ;
17765 int arg4 = (int) -1 ;
17766 bool result;
17767 void *argp1 = 0 ;
17768 int res1 = 0 ;
17769 wxPyInputStream *temp2 ;
17770 bool created2 ;
17771 bool temp3 = false ;
17772 int val4 ;
17773 int ecode4 = 0 ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 PyObject * obj2 = 0 ;
17777 PyObject * obj3 = 0 ;
17778 char * kwnames[] = {
17779 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17780 };
17781
17782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17784 if (!SWIG_IsOK(res1)) {
17785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17786 }
17787 arg1 = reinterpret_cast< wxImage * >(argp1);
17788 {
17789 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17790 arg2 = temp2->m_wxis;
17791 created2 = false;
17792 } else {
17793 PyErr_Clear(); // clear the failure of the wxPyConvert above
17794 arg2 = wxPyCBInputStream_create(obj1, false);
17795 if (arg2 == NULL) {
17796 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17797 SWIG_fail;
17798 }
17799 created2 = true;
17800 }
17801 }
17802 {
17803 arg3 = wxString_in_helper(obj2);
17804 if (arg3 == NULL) SWIG_fail;
17805 temp3 = true;
17806 }
17807 if (obj3) {
17808 ecode4 = SWIG_AsVal_int(obj3, &val4);
17809 if (!SWIG_IsOK(ecode4)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17811 }
17812 arg4 = static_cast< int >(val4);
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 {
17824 if (created2) delete arg2;
17825 }
17826 {
17827 if (temp3)
17828 delete arg3;
17829 }
17830 return resultobj;
17831 fail:
17832 {
17833 if (created2) delete arg2;
17834 }
17835 {
17836 if (temp3)
17837 delete arg3;
17838 }
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17844 PyObject *resultobj = 0;
17845 wxImage *arg1 = (wxImage *) 0 ;
17846 bool result;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 PyObject *swig_obj[1] ;
17850
17851 if (!args) SWIG_fail;
17852 swig_obj[0] = args;
17853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17854 if (!SWIG_IsOK(res1)) {
17855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17856 }
17857 arg1 = reinterpret_cast< wxImage * >(argp1);
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 result = (bool)(arg1)->IsOk();
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 {
17865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17874 PyObject *resultobj = 0;
17875 wxImage *arg1 = (wxImage *) 0 ;
17876 int result;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 PyObject *swig_obj[1] ;
17880
17881 if (!args) SWIG_fail;
17882 swig_obj[0] = args;
17883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17886 }
17887 arg1 = reinterpret_cast< wxImage * >(argp1);
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (int)(arg1)->GetWidth();
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 resultobj = SWIG_From_int(static_cast< int >(result));
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17902 PyObject *resultobj = 0;
17903 wxImage *arg1 = (wxImage *) 0 ;
17904 int result;
17905 void *argp1 = 0 ;
17906 int res1 = 0 ;
17907 PyObject *swig_obj[1] ;
17908
17909 if (!args) SWIG_fail;
17910 swig_obj[0] = args;
17911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17914 }
17915 arg1 = reinterpret_cast< wxImage * >(argp1);
17916 {
17917 PyThreadState* __tstate = wxPyBeginAllowThreads();
17918 result = (int)(arg1)->GetHeight();
17919 wxPyEndAllowThreads(__tstate);
17920 if (PyErr_Occurred()) SWIG_fail;
17921 }
17922 resultobj = SWIG_From_int(static_cast< int >(result));
17923 return resultobj;
17924 fail:
17925 return NULL;
17926 }
17927
17928
17929 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17930 PyObject *resultobj = 0;
17931 wxImage *arg1 = (wxImage *) 0 ;
17932 wxSize result;
17933 void *argp1 = 0 ;
17934 int res1 = 0 ;
17935 PyObject *swig_obj[1] ;
17936
17937 if (!args) SWIG_fail;
17938 swig_obj[0] = args;
17939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17940 if (!SWIG_IsOK(res1)) {
17941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17942 }
17943 arg1 = reinterpret_cast< wxImage * >(argp1);
17944 {
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = wxImage_GetSize(arg1);
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17958 PyObject *resultobj = 0;
17959 wxImage *arg1 = (wxImage *) 0 ;
17960 wxRect *arg2 = 0 ;
17961 SwigValueWrapper<wxImage > result;
17962 void *argp1 = 0 ;
17963 int res1 = 0 ;
17964 wxRect temp2 ;
17965 PyObject * obj0 = 0 ;
17966 PyObject * obj1 = 0 ;
17967 char * kwnames[] = {
17968 (char *) "self",(char *) "rect", NULL
17969 };
17970
17971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17973 if (!SWIG_IsOK(res1)) {
17974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17975 }
17976 arg1 = reinterpret_cast< wxImage * >(argp1);
17977 {
17978 arg2 = &temp2;
17979 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17980 }
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj = 0;
17996 wxImage *arg1 = (wxImage *) 0 ;
17997 wxSize *arg2 = 0 ;
17998 wxPoint *arg3 = 0 ;
17999 int arg4 = (int) -1 ;
18000 int arg5 = (int) -1 ;
18001 int arg6 = (int) -1 ;
18002 SwigValueWrapper<wxImage > result;
18003 void *argp1 = 0 ;
18004 int res1 = 0 ;
18005 wxSize temp2 ;
18006 wxPoint temp3 ;
18007 int val4 ;
18008 int ecode4 = 0 ;
18009 int val5 ;
18010 int ecode5 = 0 ;
18011 int val6 ;
18012 int ecode6 = 0 ;
18013 PyObject * obj0 = 0 ;
18014 PyObject * obj1 = 0 ;
18015 PyObject * obj2 = 0 ;
18016 PyObject * obj3 = 0 ;
18017 PyObject * obj4 = 0 ;
18018 PyObject * obj5 = 0 ;
18019 char * kwnames[] = {
18020 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18021 };
18022
18023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18025 if (!SWIG_IsOK(res1)) {
18026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18027 }
18028 arg1 = reinterpret_cast< wxImage * >(argp1);
18029 {
18030 arg2 = &temp2;
18031 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18032 }
18033 {
18034 arg3 = &temp3;
18035 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18036 }
18037 if (obj3) {
18038 ecode4 = SWIG_AsVal_int(obj3, &val4);
18039 if (!SWIG_IsOK(ecode4)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18041 }
18042 arg4 = static_cast< int >(val4);
18043 }
18044 if (obj4) {
18045 ecode5 = SWIG_AsVal_int(obj4, &val5);
18046 if (!SWIG_IsOK(ecode5)) {
18047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18048 }
18049 arg5 = static_cast< int >(val5);
18050 }
18051 if (obj5) {
18052 ecode6 = SWIG_AsVal_int(obj5, &val6);
18053 if (!SWIG_IsOK(ecode6)) {
18054 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18055 }
18056 arg6 = static_cast< int >(val6);
18057 }
18058 {
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18061 wxPyEndAllowThreads(__tstate);
18062 if (PyErr_Occurred()) SWIG_fail;
18063 }
18064 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18065 return resultobj;
18066 fail:
18067 return NULL;
18068 }
18069
18070
18071 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 PyObject *resultobj = 0;
18073 wxImage *arg1 = (wxImage *) 0 ;
18074 SwigValueWrapper<wxImage > result;
18075 void *argp1 = 0 ;
18076 int res1 = 0 ;
18077 PyObject *swig_obj[1] ;
18078
18079 if (!args) SWIG_fail;
18080 swig_obj[0] = args;
18081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18082 if (!SWIG_IsOK(res1)) {
18083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18084 }
18085 arg1 = reinterpret_cast< wxImage * >(argp1);
18086 {
18087 PyThreadState* __tstate = wxPyBeginAllowThreads();
18088 result = (arg1)->Copy();
18089 wxPyEndAllowThreads(__tstate);
18090 if (PyErr_Occurred()) SWIG_fail;
18091 }
18092 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18093 return resultobj;
18094 fail:
18095 return NULL;
18096 }
18097
18098
18099 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18100 PyObject *resultobj = 0;
18101 wxImage *arg1 = (wxImage *) 0 ;
18102 wxImage *arg2 = 0 ;
18103 int arg3 ;
18104 int arg4 ;
18105 void *argp1 = 0 ;
18106 int res1 = 0 ;
18107 void *argp2 = 0 ;
18108 int res2 = 0 ;
18109 int val3 ;
18110 int ecode3 = 0 ;
18111 int val4 ;
18112 int ecode4 = 0 ;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 PyObject * obj2 = 0 ;
18116 PyObject * obj3 = 0 ;
18117 char * kwnames[] = {
18118 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18119 };
18120
18121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18123 if (!SWIG_IsOK(res1)) {
18124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18125 }
18126 arg1 = reinterpret_cast< wxImage * >(argp1);
18127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18128 if (!SWIG_IsOK(res2)) {
18129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18130 }
18131 if (!argp2) {
18132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18133 }
18134 arg2 = reinterpret_cast< wxImage * >(argp2);
18135 ecode3 = SWIG_AsVal_int(obj2, &val3);
18136 if (!SWIG_IsOK(ecode3)) {
18137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18138 }
18139 arg3 = static_cast< int >(val3);
18140 ecode4 = SWIG_AsVal_int(obj3, &val4);
18141 if (!SWIG_IsOK(ecode4)) {
18142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18143 }
18144 arg4 = static_cast< int >(val4);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = SWIG_Py_Void();
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18159 PyObject *resultobj = 0;
18160 wxImage *arg1 = (wxImage *) 0 ;
18161 PyObject *result = 0 ;
18162 void *argp1 = 0 ;
18163 int res1 = 0 ;
18164 PyObject *swig_obj[1] ;
18165
18166 if (!args) SWIG_fail;
18167 swig_obj[0] = args;
18168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18169 if (!SWIG_IsOK(res1)) {
18170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18171 }
18172 arg1 = reinterpret_cast< wxImage * >(argp1);
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (PyObject *)wxImage_GetData(arg1);
18176 wxPyEndAllowThreads(__tstate);
18177 if (PyErr_Occurred()) SWIG_fail;
18178 }
18179 resultobj = result;
18180 return resultobj;
18181 fail:
18182 return NULL;
18183 }
18184
18185
18186 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj = 0;
18188 wxImage *arg1 = (wxImage *) 0 ;
18189 buffer arg2 ;
18190 int arg3 ;
18191 void *argp1 = 0 ;
18192 int res1 = 0 ;
18193 Py_ssize_t temp2 ;
18194 PyObject * obj0 = 0 ;
18195 PyObject * obj1 = 0 ;
18196 char * kwnames[] = {
18197 (char *) "self",(char *) "data", NULL
18198 };
18199
18200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18204 }
18205 arg1 = reinterpret_cast< wxImage * >(argp1);
18206 {
18207 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18208 arg3 = (int)temp2;
18209 }
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 wxImage_SetData(arg1,arg2,arg3);
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 resultobj = SWIG_Py_Void();
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18224 PyObject *resultobj = 0;
18225 wxImage *arg1 = (wxImage *) 0 ;
18226 PyObject *result = 0 ;
18227 void *argp1 = 0 ;
18228 int res1 = 0 ;
18229 PyObject *swig_obj[1] ;
18230
18231 if (!args) SWIG_fail;
18232 swig_obj[0] = args;
18233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18234 if (!SWIG_IsOK(res1)) {
18235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18236 }
18237 arg1 = reinterpret_cast< wxImage * >(argp1);
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18241 wxPyEndAllowThreads(__tstate);
18242 if (PyErr_Occurred()) SWIG_fail;
18243 }
18244 resultobj = result;
18245 return resultobj;
18246 fail:
18247 return NULL;
18248 }
18249
18250
18251 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18252 PyObject *resultobj = 0;
18253 wxImage *arg1 = (wxImage *) 0 ;
18254 buffer arg2 ;
18255 int arg3 ;
18256 void *argp1 = 0 ;
18257 int res1 = 0 ;
18258 Py_ssize_t temp2 ;
18259 PyObject * obj0 = 0 ;
18260 PyObject * obj1 = 0 ;
18261 char * kwnames[] = {
18262 (char *) "self",(char *) "data", NULL
18263 };
18264
18265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18267 if (!SWIG_IsOK(res1)) {
18268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18269 }
18270 arg1 = reinterpret_cast< wxImage * >(argp1);
18271 {
18272 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18273 arg3 = (int)temp2;
18274 }
18275 {
18276 PyThreadState* __tstate = wxPyBeginAllowThreads();
18277 wxImage_SetDataBuffer(arg1,arg2,arg3);
18278 wxPyEndAllowThreads(__tstate);
18279 if (PyErr_Occurred()) SWIG_fail;
18280 }
18281 resultobj = SWIG_Py_Void();
18282 return resultobj;
18283 fail:
18284 return NULL;
18285 }
18286
18287
18288 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18289 PyObject *resultobj = 0;
18290 wxImage *arg1 = (wxImage *) 0 ;
18291 PyObject *result = 0 ;
18292 void *argp1 = 0 ;
18293 int res1 = 0 ;
18294 PyObject *swig_obj[1] ;
18295
18296 if (!args) SWIG_fail;
18297 swig_obj[0] = args;
18298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18299 if (!SWIG_IsOK(res1)) {
18300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18301 }
18302 arg1 = reinterpret_cast< wxImage * >(argp1);
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 result = (PyObject *)wxImage_GetAlphaData(arg1);
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = result;
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18317 PyObject *resultobj = 0;
18318 wxImage *arg1 = (wxImage *) 0 ;
18319 buffer arg2 ;
18320 int arg3 ;
18321 void *argp1 = 0 ;
18322 int res1 = 0 ;
18323 Py_ssize_t temp2 ;
18324 PyObject * obj0 = 0 ;
18325 PyObject * obj1 = 0 ;
18326 char * kwnames[] = {
18327 (char *) "self",(char *) "alpha", NULL
18328 };
18329
18330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18332 if (!SWIG_IsOK(res1)) {
18333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18334 }
18335 arg1 = reinterpret_cast< wxImage * >(argp1);
18336 {
18337 if (obj1 != Py_None) {
18338 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18339 arg3 = (int)temp2;
18340 }
18341 }
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 wxImage_SetAlphaData(arg1,arg2,arg3);
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 resultobj = SWIG_Py_Void();
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18356 PyObject *resultobj = 0;
18357 wxImage *arg1 = (wxImage *) 0 ;
18358 PyObject *result = 0 ;
18359 void *argp1 = 0 ;
18360 int res1 = 0 ;
18361 PyObject *swig_obj[1] ;
18362
18363 if (!args) SWIG_fail;
18364 swig_obj[0] = args;
18365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18366 if (!SWIG_IsOK(res1)) {
18367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18368 }
18369 arg1 = reinterpret_cast< wxImage * >(argp1);
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = result;
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj = 0;
18385 wxImage *arg1 = (wxImage *) 0 ;
18386 buffer arg2 ;
18387 int arg3 ;
18388 void *argp1 = 0 ;
18389 int res1 = 0 ;
18390 Py_ssize_t temp2 ;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 char * kwnames[] = {
18394 (char *) "self",(char *) "alpha", NULL
18395 };
18396
18397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18399 if (!SWIG_IsOK(res1)) {
18400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18401 }
18402 arg1 = reinterpret_cast< wxImage * >(argp1);
18403 {
18404 if (obj1 != Py_None) {
18405 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18406 arg3 = (int)temp2;
18407 }
18408 }
18409 {
18410 PyThreadState* __tstate = wxPyBeginAllowThreads();
18411 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18412 wxPyEndAllowThreads(__tstate);
18413 if (PyErr_Occurred()) SWIG_fail;
18414 }
18415 resultobj = SWIG_Py_Void();
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj = 0;
18424 wxImage *arg1 = (wxImage *) 0 ;
18425 byte arg2 ;
18426 byte arg3 ;
18427 byte arg4 ;
18428 void *argp1 = 0 ;
18429 int res1 = 0 ;
18430 unsigned char val2 ;
18431 int ecode2 = 0 ;
18432 unsigned char val3 ;
18433 int ecode3 = 0 ;
18434 unsigned char val4 ;
18435 int ecode4 = 0 ;
18436 PyObject * obj0 = 0 ;
18437 PyObject * obj1 = 0 ;
18438 PyObject * obj2 = 0 ;
18439 PyObject * obj3 = 0 ;
18440 char * kwnames[] = {
18441 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18442 };
18443
18444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18446 if (!SWIG_IsOK(res1)) {
18447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18448 }
18449 arg1 = reinterpret_cast< wxImage * >(argp1);
18450 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18451 if (!SWIG_IsOK(ecode2)) {
18452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18453 }
18454 arg2 = static_cast< byte >(val2);
18455 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18456 if (!SWIG_IsOK(ecode3)) {
18457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18458 }
18459 arg3 = static_cast< byte >(val3);
18460 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18461 if (!SWIG_IsOK(ecode4)) {
18462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18463 }
18464 arg4 = static_cast< byte >(val4);
18465 {
18466 PyThreadState* __tstate = wxPyBeginAllowThreads();
18467 (arg1)->SetMaskColour(arg2,arg3,arg4);
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 resultobj = SWIG_Py_Void();
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18479 PyObject *resultobj = 0;
18480 wxImage *arg1 = (wxImage *) 0 ;
18481 byte *arg2 = (byte *) 0 ;
18482 byte *arg3 = (byte *) 0 ;
18483 byte *arg4 = (byte *) 0 ;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 byte temp2 ;
18487 int res2 = SWIG_TMPOBJ ;
18488 byte temp3 ;
18489 int res3 = SWIG_TMPOBJ ;
18490 byte temp4 ;
18491 int res4 = SWIG_TMPOBJ ;
18492 PyObject *swig_obj[1] ;
18493
18494 arg2 = &temp2;
18495 arg3 = &temp3;
18496 arg4 = &temp4;
18497 if (!args) SWIG_fail;
18498 swig_obj[0] = args;
18499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18500 if (!SWIG_IsOK(res1)) {
18501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18502 }
18503 arg1 = reinterpret_cast< wxImage * >(argp1);
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18507 wxPyEndAllowThreads(__tstate);
18508 if (PyErr_Occurred()) SWIG_fail;
18509 }
18510 resultobj = SWIG_Py_Void();
18511 if (SWIG_IsTmpObj(res2)) {
18512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18513 } else {
18514 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18516 }
18517 if (SWIG_IsTmpObj(res3)) {
18518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18519 } else {
18520 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18522 }
18523 if (SWIG_IsTmpObj(res4)) {
18524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18525 } else {
18526 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18528 }
18529 return resultobj;
18530 fail:
18531 return NULL;
18532 }
18533
18534
18535 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18536 PyObject *resultobj = 0;
18537 wxImage *arg1 = (wxImage *) 0 ;
18538 byte result;
18539 void *argp1 = 0 ;
18540 int res1 = 0 ;
18541 PyObject *swig_obj[1] ;
18542
18543 if (!args) SWIG_fail;
18544 swig_obj[0] = args;
18545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18546 if (!SWIG_IsOK(res1)) {
18547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18548 }
18549 arg1 = reinterpret_cast< wxImage * >(argp1);
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (byte)(arg1)->GetMaskRed();
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18557 return resultobj;
18558 fail:
18559 return NULL;
18560 }
18561
18562
18563 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18564 PyObject *resultobj = 0;
18565 wxImage *arg1 = (wxImage *) 0 ;
18566 byte result;
18567 void *argp1 = 0 ;
18568 int res1 = 0 ;
18569 PyObject *swig_obj[1] ;
18570
18571 if (!args) SWIG_fail;
18572 swig_obj[0] = args;
18573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18576 }
18577 arg1 = reinterpret_cast< wxImage * >(argp1);
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 result = (byte)(arg1)->GetMaskGreen();
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18585 return resultobj;
18586 fail:
18587 return NULL;
18588 }
18589
18590
18591 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18592 PyObject *resultobj = 0;
18593 wxImage *arg1 = (wxImage *) 0 ;
18594 byte result;
18595 void *argp1 = 0 ;
18596 int res1 = 0 ;
18597 PyObject *swig_obj[1] ;
18598
18599 if (!args) SWIG_fail;
18600 swig_obj[0] = args;
18601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18602 if (!SWIG_IsOK(res1)) {
18603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18604 }
18605 arg1 = reinterpret_cast< wxImage * >(argp1);
18606 {
18607 PyThreadState* __tstate = wxPyBeginAllowThreads();
18608 result = (byte)(arg1)->GetMaskBlue();
18609 wxPyEndAllowThreads(__tstate);
18610 if (PyErr_Occurred()) SWIG_fail;
18611 }
18612 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18613 return resultobj;
18614 fail:
18615 return NULL;
18616 }
18617
18618
18619 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18620 PyObject *resultobj = 0;
18621 wxImage *arg1 = (wxImage *) 0 ;
18622 bool arg2 = (bool) true ;
18623 void *argp1 = 0 ;
18624 int res1 = 0 ;
18625 bool val2 ;
18626 int ecode2 = 0 ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 char * kwnames[] = {
18630 (char *) "self",(char *) "mask", NULL
18631 };
18632
18633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18635 if (!SWIG_IsOK(res1)) {
18636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18637 }
18638 arg1 = reinterpret_cast< wxImage * >(argp1);
18639 if (obj1) {
18640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18641 if (!SWIG_IsOK(ecode2)) {
18642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18643 }
18644 arg2 = static_cast< bool >(val2);
18645 }
18646 {
18647 PyThreadState* __tstate = wxPyBeginAllowThreads();
18648 (arg1)->SetMask(arg2);
18649 wxPyEndAllowThreads(__tstate);
18650 if (PyErr_Occurred()) SWIG_fail;
18651 }
18652 resultobj = SWIG_Py_Void();
18653 return resultobj;
18654 fail:
18655 return NULL;
18656 }
18657
18658
18659 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18660 PyObject *resultobj = 0;
18661 wxImage *arg1 = (wxImage *) 0 ;
18662 bool result;
18663 void *argp1 = 0 ;
18664 int res1 = 0 ;
18665 PyObject *swig_obj[1] ;
18666
18667 if (!args) SWIG_fail;
18668 swig_obj[0] = args;
18669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18670 if (!SWIG_IsOK(res1)) {
18671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18672 }
18673 arg1 = reinterpret_cast< wxImage * >(argp1);
18674 {
18675 PyThreadState* __tstate = wxPyBeginAllowThreads();
18676 result = (bool)(arg1)->HasMask();
18677 wxPyEndAllowThreads(__tstate);
18678 if (PyErr_Occurred()) SWIG_fail;
18679 }
18680 {
18681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18682 }
18683 return resultobj;
18684 fail:
18685 return NULL;
18686 }
18687
18688
18689 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18690 PyObject *resultobj = 0;
18691 wxImage *arg1 = (wxImage *) 0 ;
18692 double arg2 ;
18693 wxPoint *arg3 = 0 ;
18694 bool arg4 = (bool) true ;
18695 wxPoint *arg5 = (wxPoint *) NULL ;
18696 SwigValueWrapper<wxImage > result;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 double val2 ;
18700 int ecode2 = 0 ;
18701 wxPoint temp3 ;
18702 bool val4 ;
18703 int ecode4 = 0 ;
18704 void *argp5 = 0 ;
18705 int res5 = 0 ;
18706 PyObject * obj0 = 0 ;
18707 PyObject * obj1 = 0 ;
18708 PyObject * obj2 = 0 ;
18709 PyObject * obj3 = 0 ;
18710 PyObject * obj4 = 0 ;
18711 char * kwnames[] = {
18712 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18713 };
18714
18715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18717 if (!SWIG_IsOK(res1)) {
18718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18719 }
18720 arg1 = reinterpret_cast< wxImage * >(argp1);
18721 ecode2 = SWIG_AsVal_double(obj1, &val2);
18722 if (!SWIG_IsOK(ecode2)) {
18723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18724 }
18725 arg2 = static_cast< double >(val2);
18726 {
18727 arg3 = &temp3;
18728 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18729 }
18730 if (obj3) {
18731 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18732 if (!SWIG_IsOK(ecode4)) {
18733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18734 }
18735 arg4 = static_cast< bool >(val4);
18736 }
18737 if (obj4) {
18738 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18739 if (!SWIG_IsOK(res5)) {
18740 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18741 }
18742 arg5 = reinterpret_cast< wxPoint * >(argp5);
18743 }
18744 {
18745 PyThreadState* __tstate = wxPyBeginAllowThreads();
18746 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18747 wxPyEndAllowThreads(__tstate);
18748 if (PyErr_Occurred()) SWIG_fail;
18749 }
18750 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj = 0;
18759 wxImage *arg1 = (wxImage *) 0 ;
18760 bool arg2 = (bool) true ;
18761 SwigValueWrapper<wxImage > result;
18762 void *argp1 = 0 ;
18763 int res1 = 0 ;
18764 bool val2 ;
18765 int ecode2 = 0 ;
18766 PyObject * obj0 = 0 ;
18767 PyObject * obj1 = 0 ;
18768 char * kwnames[] = {
18769 (char *) "self",(char *) "clockwise", NULL
18770 };
18771
18772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18774 if (!SWIG_IsOK(res1)) {
18775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18776 }
18777 arg1 = reinterpret_cast< wxImage * >(argp1);
18778 if (obj1) {
18779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18780 if (!SWIG_IsOK(ecode2)) {
18781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18782 }
18783 arg2 = static_cast< bool >(val2);
18784 }
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (arg1)->Rotate90(arg2);
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxImage *arg1 = (wxImage *) 0 ;
18801 bool arg2 = (bool) true ;
18802 SwigValueWrapper<wxImage > result;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 bool val2 ;
18806 int ecode2 = 0 ;
18807 PyObject * obj0 = 0 ;
18808 PyObject * obj1 = 0 ;
18809 char * kwnames[] = {
18810 (char *) "self",(char *) "horizontally", NULL
18811 };
18812
18813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18815 if (!SWIG_IsOK(res1)) {
18816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18817 }
18818 arg1 = reinterpret_cast< wxImage * >(argp1);
18819 if (obj1) {
18820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18821 if (!SWIG_IsOK(ecode2)) {
18822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18823 }
18824 arg2 = static_cast< bool >(val2);
18825 }
18826 {
18827 PyThreadState* __tstate = wxPyBeginAllowThreads();
18828 result = (arg1)->Mirror(arg2);
18829 wxPyEndAllowThreads(__tstate);
18830 if (PyErr_Occurred()) SWIG_fail;
18831 }
18832 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj = 0;
18841 wxImage *arg1 = (wxImage *) 0 ;
18842 byte arg2 ;
18843 byte arg3 ;
18844 byte arg4 ;
18845 byte arg5 ;
18846 byte arg6 ;
18847 byte arg7 ;
18848 void *argp1 = 0 ;
18849 int res1 = 0 ;
18850 unsigned char val2 ;
18851 int ecode2 = 0 ;
18852 unsigned char val3 ;
18853 int ecode3 = 0 ;
18854 unsigned char val4 ;
18855 int ecode4 = 0 ;
18856 unsigned char val5 ;
18857 int ecode5 = 0 ;
18858 unsigned char val6 ;
18859 int ecode6 = 0 ;
18860 unsigned char val7 ;
18861 int ecode7 = 0 ;
18862 PyObject * obj0 = 0 ;
18863 PyObject * obj1 = 0 ;
18864 PyObject * obj2 = 0 ;
18865 PyObject * obj3 = 0 ;
18866 PyObject * obj4 = 0 ;
18867 PyObject * obj5 = 0 ;
18868 PyObject * obj6 = 0 ;
18869 char * kwnames[] = {
18870 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18871 };
18872
18873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18875 if (!SWIG_IsOK(res1)) {
18876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18877 }
18878 arg1 = reinterpret_cast< wxImage * >(argp1);
18879 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18880 if (!SWIG_IsOK(ecode2)) {
18881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18882 }
18883 arg2 = static_cast< byte >(val2);
18884 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18885 if (!SWIG_IsOK(ecode3)) {
18886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18887 }
18888 arg3 = static_cast< byte >(val3);
18889 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18890 if (!SWIG_IsOK(ecode4)) {
18891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18892 }
18893 arg4 = static_cast< byte >(val4);
18894 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18895 if (!SWIG_IsOK(ecode5)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18897 }
18898 arg5 = static_cast< byte >(val5);
18899 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18900 if (!SWIG_IsOK(ecode6)) {
18901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18902 }
18903 arg6 = static_cast< byte >(val6);
18904 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18905 if (!SWIG_IsOK(ecode7)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18907 }
18908 arg7 = static_cast< byte >(val7);
18909 {
18910 PyThreadState* __tstate = wxPyBeginAllowThreads();
18911 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 resultobj = SWIG_Py_Void();
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18923 PyObject *resultobj = 0;
18924 wxImage *arg1 = (wxImage *) 0 ;
18925 double arg2 = (double) 0.299 ;
18926 double arg3 = (double) 0.587 ;
18927 double arg4 = (double) 0.114 ;
18928 SwigValueWrapper<wxImage > result;
18929 void *argp1 = 0 ;
18930 int res1 = 0 ;
18931 double val2 ;
18932 int ecode2 = 0 ;
18933 double val3 ;
18934 int ecode3 = 0 ;
18935 double val4 ;
18936 int ecode4 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 PyObject * obj2 = 0 ;
18940 PyObject * obj3 = 0 ;
18941 char * kwnames[] = {
18942 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18943 };
18944
18945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18947 if (!SWIG_IsOK(res1)) {
18948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18949 }
18950 arg1 = reinterpret_cast< wxImage * >(argp1);
18951 if (obj1) {
18952 ecode2 = SWIG_AsVal_double(obj1, &val2);
18953 if (!SWIG_IsOK(ecode2)) {
18954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18955 }
18956 arg2 = static_cast< double >(val2);
18957 }
18958 if (obj2) {
18959 ecode3 = SWIG_AsVal_double(obj2, &val3);
18960 if (!SWIG_IsOK(ecode3)) {
18961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18962 }
18963 arg3 = static_cast< double >(val3);
18964 }
18965 if (obj3) {
18966 ecode4 = SWIG_AsVal_double(obj3, &val4);
18967 if (!SWIG_IsOK(ecode4)) {
18968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18969 }
18970 arg4 = static_cast< double >(val4);
18971 }
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj = 0;
18987 wxImage *arg1 = (wxImage *) 0 ;
18988 byte arg2 ;
18989 byte arg3 ;
18990 byte arg4 ;
18991 SwigValueWrapper<wxImage > result;
18992 void *argp1 = 0 ;
18993 int res1 = 0 ;
18994 unsigned char val2 ;
18995 int ecode2 = 0 ;
18996 unsigned char val3 ;
18997 int ecode3 = 0 ;
18998 unsigned char val4 ;
18999 int ecode4 = 0 ;
19000 PyObject * obj0 = 0 ;
19001 PyObject * obj1 = 0 ;
19002 PyObject * obj2 = 0 ;
19003 PyObject * obj3 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19012 }
19013 arg1 = reinterpret_cast< wxImage * >(argp1);
19014 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19015 if (!SWIG_IsOK(ecode2)) {
19016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19017 }
19018 arg2 = static_cast< byte >(val2);
19019 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19020 if (!SWIG_IsOK(ecode3)) {
19021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19022 }
19023 arg3 = static_cast< byte >(val3);
19024 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19025 if (!SWIG_IsOK(ecode4)) {
19026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19027 }
19028 arg4 = static_cast< byte >(val4);
19029 {
19030 PyThreadState* __tstate = wxPyBeginAllowThreads();
19031 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19032 wxPyEndAllowThreads(__tstate);
19033 if (PyErr_Occurred()) SWIG_fail;
19034 }
19035 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj = 0;
19044 wxImage *arg1 = (wxImage *) 0 ;
19045 wxString *arg2 = 0 ;
19046 wxString *arg3 = 0 ;
19047 void *argp1 = 0 ;
19048 int res1 = 0 ;
19049 bool temp2 = false ;
19050 bool temp3 = false ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 PyObject * obj2 = 0 ;
19054 char * kwnames[] = {
19055 (char *) "self",(char *) "name",(char *) "value", NULL
19056 };
19057
19058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19060 if (!SWIG_IsOK(res1)) {
19061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19062 }
19063 arg1 = reinterpret_cast< wxImage * >(argp1);
19064 {
19065 arg2 = wxString_in_helper(obj1);
19066 if (arg2 == NULL) SWIG_fail;
19067 temp2 = true;
19068 }
19069 {
19070 arg3 = wxString_in_helper(obj2);
19071 if (arg3 == NULL) SWIG_fail;
19072 temp3 = true;
19073 }
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 resultobj = SWIG_Py_Void();
19081 {
19082 if (temp2)
19083 delete arg2;
19084 }
19085 {
19086 if (temp3)
19087 delete arg3;
19088 }
19089 return resultobj;
19090 fail:
19091 {
19092 if (temp2)
19093 delete arg2;
19094 }
19095 {
19096 if (temp3)
19097 delete arg3;
19098 }
19099 return NULL;
19100 }
19101
19102
19103 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19104 PyObject *resultobj = 0;
19105 wxImage *arg1 = (wxImage *) 0 ;
19106 wxString *arg2 = 0 ;
19107 int arg3 ;
19108 void *argp1 = 0 ;
19109 int res1 = 0 ;
19110 bool temp2 = false ;
19111 int val3 ;
19112 int ecode3 = 0 ;
19113 PyObject * obj0 = 0 ;
19114 PyObject * obj1 = 0 ;
19115 PyObject * obj2 = 0 ;
19116 char * kwnames[] = {
19117 (char *) "self",(char *) "name",(char *) "value", NULL
19118 };
19119
19120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19122 if (!SWIG_IsOK(res1)) {
19123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19124 }
19125 arg1 = reinterpret_cast< wxImage * >(argp1);
19126 {
19127 arg2 = wxString_in_helper(obj1);
19128 if (arg2 == NULL) SWIG_fail;
19129 temp2 = true;
19130 }
19131 ecode3 = SWIG_AsVal_int(obj2, &val3);
19132 if (!SWIG_IsOK(ecode3)) {
19133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19134 }
19135 arg3 = static_cast< int >(val3);
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 (arg1)->SetOption((wxString const &)*arg2,arg3);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = SWIG_Py_Void();
19143 {
19144 if (temp2)
19145 delete arg2;
19146 }
19147 return resultobj;
19148 fail:
19149 {
19150 if (temp2)
19151 delete arg2;
19152 }
19153 return NULL;
19154 }
19155
19156
19157 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj = 0;
19159 wxImage *arg1 = (wxImage *) 0 ;
19160 wxString *arg2 = 0 ;
19161 wxString result;
19162 void *argp1 = 0 ;
19163 int res1 = 0 ;
19164 bool temp2 = false ;
19165 PyObject * obj0 = 0 ;
19166 PyObject * obj1 = 0 ;
19167 char * kwnames[] = {
19168 (char *) "self",(char *) "name", NULL
19169 };
19170
19171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19173 if (!SWIG_IsOK(res1)) {
19174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19175 }
19176 arg1 = reinterpret_cast< wxImage * >(argp1);
19177 {
19178 arg2 = wxString_in_helper(obj1);
19179 if (arg2 == NULL) SWIG_fail;
19180 temp2 = true;
19181 }
19182 {
19183 PyThreadState* __tstate = wxPyBeginAllowThreads();
19184 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19185 wxPyEndAllowThreads(__tstate);
19186 if (PyErr_Occurred()) SWIG_fail;
19187 }
19188 {
19189 #if wxUSE_UNICODE
19190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19191 #else
19192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19193 #endif
19194 }
19195 {
19196 if (temp2)
19197 delete arg2;
19198 }
19199 return resultobj;
19200 fail:
19201 {
19202 if (temp2)
19203 delete arg2;
19204 }
19205 return NULL;
19206 }
19207
19208
19209 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj = 0;
19211 wxImage *arg1 = (wxImage *) 0 ;
19212 wxString *arg2 = 0 ;
19213 int result;
19214 void *argp1 = 0 ;
19215 int res1 = 0 ;
19216 bool temp2 = false ;
19217 PyObject * obj0 = 0 ;
19218 PyObject * obj1 = 0 ;
19219 char * kwnames[] = {
19220 (char *) "self",(char *) "name", NULL
19221 };
19222
19223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19227 }
19228 arg1 = reinterpret_cast< wxImage * >(argp1);
19229 {
19230 arg2 = wxString_in_helper(obj1);
19231 if (arg2 == NULL) SWIG_fail;
19232 temp2 = true;
19233 }
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 resultobj = SWIG_From_int(static_cast< int >(result));
19241 {
19242 if (temp2)
19243 delete arg2;
19244 }
19245 return resultobj;
19246 fail:
19247 {
19248 if (temp2)
19249 delete arg2;
19250 }
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj = 0;
19257 wxImage *arg1 = (wxImage *) 0 ;
19258 wxString *arg2 = 0 ;
19259 bool result;
19260 void *argp1 = 0 ;
19261 int res1 = 0 ;
19262 bool temp2 = false ;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char * kwnames[] = {
19266 (char *) "self",(char *) "name", NULL
19267 };
19268
19269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19271 if (!SWIG_IsOK(res1)) {
19272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19273 }
19274 arg1 = reinterpret_cast< wxImage * >(argp1);
19275 {
19276 arg2 = wxString_in_helper(obj1);
19277 if (arg2 == NULL) SWIG_fail;
19278 temp2 = true;
19279 }
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19283 wxPyEndAllowThreads(__tstate);
19284 if (PyErr_Occurred()) SWIG_fail;
19285 }
19286 {
19287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19288 }
19289 {
19290 if (temp2)
19291 delete arg2;
19292 }
19293 return resultobj;
19294 fail:
19295 {
19296 if (temp2)
19297 delete arg2;
19298 }
19299 return NULL;
19300 }
19301
19302
19303 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19304 PyObject *resultobj = 0;
19305 wxImage *arg1 = (wxImage *) 0 ;
19306 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19307 unsigned long result;
19308 void *argp1 = 0 ;
19309 int res1 = 0 ;
19310 unsigned long val2 ;
19311 int ecode2 = 0 ;
19312 PyObject * obj0 = 0 ;
19313 PyObject * obj1 = 0 ;
19314 char * kwnames[] = {
19315 (char *) "self",(char *) "stopafter", NULL
19316 };
19317
19318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19320 if (!SWIG_IsOK(res1)) {
19321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19322 }
19323 arg1 = reinterpret_cast< wxImage * >(argp1);
19324 if (obj1) {
19325 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19326 if (!SWIG_IsOK(ecode2)) {
19327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19328 }
19329 arg2 = static_cast< unsigned long >(val2);
19330 }
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = (unsigned long)(arg1)->CountColours(arg2);
19334 wxPyEndAllowThreads(__tstate);
19335 if (PyErr_Occurred()) SWIG_fail;
19336 }
19337 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19338 return resultobj;
19339 fail:
19340 return NULL;
19341 }
19342
19343
19344 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19345 PyObject *resultobj = 0;
19346 wxImage *arg1 = (wxImage *) 0 ;
19347 wxImageHistogram *arg2 = 0 ;
19348 unsigned long result;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 void *argp2 = 0 ;
19352 int res2 = 0 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "self",(char *) "h", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19363 }
19364 arg1 = reinterpret_cast< wxImage * >(argp1);
19365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19366 if (!SWIG_IsOK(res2)) {
19367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19368 }
19369 if (!argp2) {
19370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19371 }
19372 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19387 PyObject *resultobj = 0;
19388 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19389 void *argp1 = 0 ;
19390 int res1 = 0 ;
19391 PyObject * obj0 = 0 ;
19392 char * kwnames[] = {
19393 (char *) "handler", NULL
19394 };
19395
19396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19398 if (!SWIG_IsOK(res1)) {
19399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19400 }
19401 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19402 {
19403 PyThreadState* __tstate = wxPyBeginAllowThreads();
19404 wxImage::AddHandler(arg1);
19405 wxPyEndAllowThreads(__tstate);
19406 if (PyErr_Occurred()) SWIG_fail;
19407 }
19408 resultobj = SWIG_Py_Void();
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj = 0;
19417 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19418 void *argp1 = 0 ;
19419 int res1 = 0 ;
19420 PyObject * obj0 = 0 ;
19421 char * kwnames[] = {
19422 (char *) "handler", NULL
19423 };
19424
19425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19429 }
19430 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 wxImage::InsertHandler(arg1);
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 resultobj = SWIG_Py_Void();
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj = 0;
19446 wxString *arg1 = 0 ;
19447 bool result;
19448 bool temp1 = false ;
19449 PyObject * obj0 = 0 ;
19450 char * kwnames[] = {
19451 (char *) "name", NULL
19452 };
19453
19454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19455 {
19456 arg1 = wxString_in_helper(obj0);
19457 if (arg1 == NULL) SWIG_fail;
19458 temp1 = true;
19459 }
19460 {
19461 PyThreadState* __tstate = wxPyBeginAllowThreads();
19462 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 {
19467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19468 }
19469 {
19470 if (temp1)
19471 delete arg1;
19472 }
19473 return resultobj;
19474 fail:
19475 {
19476 if (temp1)
19477 delete arg1;
19478 }
19479 return NULL;
19480 }
19481
19482
19483 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19484 PyObject *resultobj = 0;
19485 PyObject *result = 0 ;
19486
19487 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19488 {
19489 PyThreadState* __tstate = wxPyBeginAllowThreads();
19490 result = (PyObject *)wxImage_GetHandlers();
19491 wxPyEndAllowThreads(__tstate);
19492 if (PyErr_Occurred()) SWIG_fail;
19493 }
19494 resultobj = result;
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19502 PyObject *resultobj = 0;
19503 wxString result;
19504
19505 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = wxImage::GetImageExtWildcard();
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 {
19513 #if wxUSE_UNICODE
19514 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19515 #else
19516 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19517 #endif
19518 }
19519 return resultobj;
19520 fail:
19521 return NULL;
19522 }
19523
19524
19525 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxImage *arg1 = (wxImage *) 0 ;
19528 int arg2 = (int) -1 ;
19529 wxBitmap result;
19530 void *argp1 = 0 ;
19531 int res1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 char * kwnames[] = {
19537 (char *) "self",(char *) "depth", NULL
19538 };
19539
19540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19542 if (!SWIG_IsOK(res1)) {
19543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19544 }
19545 arg1 = reinterpret_cast< wxImage * >(argp1);
19546 if (obj1) {
19547 ecode2 = SWIG_AsVal_int(obj1, &val2);
19548 if (!SWIG_IsOK(ecode2)) {
19549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19550 }
19551 arg2 = static_cast< int >(val2);
19552 }
19553 {
19554 if (!wxPyCheckForApp()) SWIG_fail;
19555 PyThreadState* __tstate = wxPyBeginAllowThreads();
19556 result = wxImage_ConvertToBitmap(arg1,arg2);
19557 wxPyEndAllowThreads(__tstate);
19558 if (PyErr_Occurred()) SWIG_fail;
19559 }
19560 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj = 0;
19569 wxImage *arg1 = (wxImage *) 0 ;
19570 byte arg2 ;
19571 byte arg3 ;
19572 byte arg4 ;
19573 wxBitmap result;
19574 void *argp1 = 0 ;
19575 int res1 = 0 ;
19576 unsigned char val2 ;
19577 int ecode2 = 0 ;
19578 unsigned char val3 ;
19579 int ecode3 = 0 ;
19580 unsigned char val4 ;
19581 int ecode4 = 0 ;
19582 PyObject * obj0 = 0 ;
19583 PyObject * obj1 = 0 ;
19584 PyObject * obj2 = 0 ;
19585 PyObject * obj3 = 0 ;
19586 char * kwnames[] = {
19587 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19588 };
19589
19590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19592 if (!SWIG_IsOK(res1)) {
19593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19594 }
19595 arg1 = reinterpret_cast< wxImage * >(argp1);
19596 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19597 if (!SWIG_IsOK(ecode2)) {
19598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19599 }
19600 arg2 = static_cast< byte >(val2);
19601 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19602 if (!SWIG_IsOK(ecode3)) {
19603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19604 }
19605 arg3 = static_cast< byte >(val3);
19606 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19607 if (!SWIG_IsOK(ecode4)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19609 }
19610 arg4 = static_cast< byte >(val4);
19611 {
19612 if (!wxPyCheckForApp()) SWIG_fail;
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = 0;
19627 wxImage *arg1 = (wxImage *) 0 ;
19628 double arg2 ;
19629 void *argp1 = 0 ;
19630 int res1 = 0 ;
19631 double val2 ;
19632 int ecode2 = 0 ;
19633 PyObject * obj0 = 0 ;
19634 PyObject * obj1 = 0 ;
19635 char * kwnames[] = {
19636 (char *) "self",(char *) "angle", NULL
19637 };
19638
19639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19643 }
19644 arg1 = reinterpret_cast< wxImage * >(argp1);
19645 ecode2 = SWIG_AsVal_double(obj1, &val2);
19646 if (!SWIG_IsOK(ecode2)) {
19647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19648 }
19649 arg2 = static_cast< double >(val2);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 (arg1)->RotateHue(arg2);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_Py_Void();
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = 0;
19665 wxImage_RGBValue arg1 ;
19666 wxImage_HSVValue result;
19667 void *argp1 ;
19668 int res1 = 0 ;
19669 PyObject * obj0 = 0 ;
19670 char * kwnames[] = {
19671 (char *) "rgb", NULL
19672 };
19673
19674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19675 {
19676 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19677 if (!SWIG_IsOK(res1)) {
19678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19679 }
19680 if (!argp1) {
19681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19682 } else {
19683 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19684 arg1 = *temp;
19685 if (SWIG_IsNewObj(res1)) delete temp;
19686 }
19687 }
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = wxImage::RGBtoHSV(arg1);
19691 wxPyEndAllowThreads(__tstate);
19692 if (PyErr_Occurred()) SWIG_fail;
19693 }
19694 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19695 return resultobj;
19696 fail:
19697 return NULL;
19698 }
19699
19700
19701 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19702 PyObject *resultobj = 0;
19703 wxImage_HSVValue arg1 ;
19704 wxImage_RGBValue result;
19705 void *argp1 ;
19706 int res1 = 0 ;
19707 PyObject * obj0 = 0 ;
19708 char * kwnames[] = {
19709 (char *) "hsv", NULL
19710 };
19711
19712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19713 {
19714 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19715 if (!SWIG_IsOK(res1)) {
19716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19717 }
19718 if (!argp1) {
19719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19720 } else {
19721 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19722 arg1 = *temp;
19723 if (SWIG_IsNewObj(res1)) delete temp;
19724 }
19725 }
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 result = wxImage::HSVtoRGB(arg1);
19729 wxPyEndAllowThreads(__tstate);
19730 if (PyErr_Occurred()) SWIG_fail;
19731 }
19732 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19740 PyObject *obj;
19741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19742 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19743 return SWIG_Py_Void();
19744 }
19745
19746 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19747 return SWIG_Python_InitShadowInstance(args);
19748 }
19749
19750 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19751 PyObject *resultobj = 0;
19752 int arg1 ;
19753 int arg2 ;
19754 buffer arg3 ;
19755 int arg4 ;
19756 buffer arg5 = (buffer) NULL ;
19757 int arg6 = (int) 0 ;
19758 wxImage *result = 0 ;
19759 int val1 ;
19760 int ecode1 = 0 ;
19761 int val2 ;
19762 int ecode2 = 0 ;
19763 Py_ssize_t temp3 ;
19764 Py_ssize_t temp5 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 PyObject * obj2 = 0 ;
19768 PyObject * obj3 = 0 ;
19769 char * kwnames[] = {
19770 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19771 };
19772
19773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19774 ecode1 = SWIG_AsVal_int(obj0, &val1);
19775 if (!SWIG_IsOK(ecode1)) {
19776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19777 }
19778 arg1 = static_cast< int >(val1);
19779 ecode2 = SWIG_AsVal_int(obj1, &val2);
19780 if (!SWIG_IsOK(ecode2)) {
19781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19782 }
19783 arg2 = static_cast< int >(val2);
19784 {
19785 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19786 arg4 = (int)temp3;
19787 }
19788 if (obj3) {
19789 {
19790 if (obj3 != Py_None) {
19791 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19792 arg6 = (int)temp5;
19793 }
19794 }
19795 }
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 {
19803 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19804 }
19805 return resultobj;
19806 fail:
19807 return NULL;
19808 }
19809
19810
19811 SWIGINTERN int NullImage_set(PyObject *) {
19812 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19813 return 1;
19814 }
19815
19816
19817 SWIGINTERN PyObject *NullImage_get(void) {
19818 PyObject *pyobj = 0;
19819
19820 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19821 return pyobj;
19822 }
19823
19824
19825 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19826 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19827 return 1;
19828 }
19829
19830
19831 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19832 PyObject *pyobj = 0;
19833
19834 {
19835 #if wxUSE_UNICODE
19836 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19837 #else
19838 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19839 #endif
19840 }
19841 return pyobj;
19842 }
19843
19844
19845 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19846 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19847 return 1;
19848 }
19849
19850
19851 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19852 PyObject *pyobj = 0;
19853
19854 {
19855 #if wxUSE_UNICODE
19856 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19857 #else
19858 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19859 #endif
19860 }
19861 return pyobj;
19862 }
19863
19864
19865 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19866 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19867 return 1;
19868 }
19869
19870
19871 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19872 PyObject *pyobj = 0;
19873
19874 {
19875 #if wxUSE_UNICODE
19876 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19877 #else
19878 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19879 #endif
19880 }
19881 return pyobj;
19882 }
19883
19884
19885 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 {
19895 #if wxUSE_UNICODE
19896 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19897 #else
19898 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19899 #endif
19900 }
19901 return pyobj;
19902 }
19903
19904
19905 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19906 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19907 return 1;
19908 }
19909
19910
19911 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19912 PyObject *pyobj = 0;
19913
19914 {
19915 #if wxUSE_UNICODE
19916 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19917 #else
19918 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19919 #endif
19920 }
19921 return pyobj;
19922 }
19923
19924
19925 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19926 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19927 return 1;
19928 }
19929
19930
19931 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19932 PyObject *pyobj = 0;
19933
19934 {
19935 #if wxUSE_UNICODE
19936 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19937 #else
19938 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19939 #endif
19940 }
19941 return pyobj;
19942 }
19943
19944
19945 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19947 return 1;
19948 }
19949
19950
19951 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19952 PyObject *pyobj = 0;
19953
19954 {
19955 #if wxUSE_UNICODE
19956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19957 #else
19958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19959 #endif
19960 }
19961 return pyobj;
19962 }
19963
19964
19965 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19967 return 1;
19968 }
19969
19970
19971 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19972 PyObject *pyobj = 0;
19973
19974 {
19975 #if wxUSE_UNICODE
19976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19977 #else
19978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19979 #endif
19980 }
19981 return pyobj;
19982 }
19983
19984
19985 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19987 return 1;
19988 }
19989
19990
19991 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19992 PyObject *pyobj = 0;
19993
19994 {
19995 #if wxUSE_UNICODE
19996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19997 #else
19998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19999 #endif
20000 }
20001 return pyobj;
20002 }
20003
20004
20005 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20007 return 1;
20008 }
20009
20010
20011 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20012 PyObject *pyobj = 0;
20013
20014 {
20015 #if wxUSE_UNICODE
20016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20017 #else
20018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20019 #endif
20020 }
20021 return pyobj;
20022 }
20023
20024
20025 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20027 return 1;
20028 }
20029
20030
20031 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20032 PyObject *pyobj = 0;
20033
20034 {
20035 #if wxUSE_UNICODE
20036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20037 #else
20038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20039 #endif
20040 }
20041 return pyobj;
20042 }
20043
20044
20045 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20047 return 1;
20048 }
20049
20050
20051 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20052 PyObject *pyobj = 0;
20053
20054 {
20055 #if wxUSE_UNICODE
20056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20057 #else
20058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20059 #endif
20060 }
20061 return pyobj;
20062 }
20063
20064
20065 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20066 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20067 return 1;
20068 }
20069
20070
20071 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20072 PyObject *pyobj = 0;
20073
20074 {
20075 #if wxUSE_UNICODE
20076 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20077 #else
20078 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20079 #endif
20080 }
20081 return pyobj;
20082 }
20083
20084
20085 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20086 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20087 return 1;
20088 }
20089
20090
20091 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20092 PyObject *pyobj = 0;
20093
20094 {
20095 #if wxUSE_UNICODE
20096 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20097 #else
20098 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20099 #endif
20100 }
20101 return pyobj;
20102 }
20103
20104
20105 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20106 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20107 return 1;
20108 }
20109
20110
20111 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20112 PyObject *pyobj = 0;
20113
20114 {
20115 #if wxUSE_UNICODE
20116 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20117 #else
20118 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20119 #endif
20120 }
20121 return pyobj;
20122 }
20123
20124
20125 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20126 PyObject *resultobj = 0;
20127 wxBMPHandler *result = 0 ;
20128
20129 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20130 {
20131 PyThreadState* __tstate = wxPyBeginAllowThreads();
20132 result = (wxBMPHandler *)new wxBMPHandler();
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20144 PyObject *obj;
20145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20146 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20147 return SWIG_Py_Void();
20148 }
20149
20150 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20151 return SWIG_Python_InitShadowInstance(args);
20152 }
20153
20154 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 PyObject *resultobj = 0;
20156 wxICOHandler *result = 0 ;
20157
20158 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (wxICOHandler *)new wxICOHandler();
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20166 return resultobj;
20167 fail:
20168 return NULL;
20169 }
20170
20171
20172 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20173 PyObject *obj;
20174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20175 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20176 return SWIG_Py_Void();
20177 }
20178
20179 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 return SWIG_Python_InitShadowInstance(args);
20181 }
20182
20183 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 PyObject *resultobj = 0;
20185 wxCURHandler *result = 0 ;
20186
20187 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (wxCURHandler *)new wxCURHandler();
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20195 return resultobj;
20196 fail:
20197 return NULL;
20198 }
20199
20200
20201 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20202 PyObject *obj;
20203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20204 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20205 return SWIG_Py_Void();
20206 }
20207
20208 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20209 return SWIG_Python_InitShadowInstance(args);
20210 }
20211
20212 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxANIHandler *result = 0 ;
20215
20216 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (wxANIHandler *)new wxANIHandler();
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20231 PyObject *obj;
20232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20233 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20234 return SWIG_Py_Void();
20235 }
20236
20237 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20238 return SWIG_Python_InitShadowInstance(args);
20239 }
20240
20241 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 PyObject *resultobj = 0;
20243 wxPNGHandler *result = 0 ;
20244
20245 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 result = (wxPNGHandler *)new wxPNGHandler();
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20260 PyObject *obj;
20261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20262 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20263 return SWIG_Py_Void();
20264 }
20265
20266 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20267 return SWIG_Python_InitShadowInstance(args);
20268 }
20269
20270 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20271 PyObject *resultobj = 0;
20272 wxGIFHandler *result = 0 ;
20273
20274 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20275 {
20276 PyThreadState* __tstate = wxPyBeginAllowThreads();
20277 result = (wxGIFHandler *)new wxGIFHandler();
20278 wxPyEndAllowThreads(__tstate);
20279 if (PyErr_Occurred()) SWIG_fail;
20280 }
20281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20289 PyObject *obj;
20290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20291 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20292 return SWIG_Py_Void();
20293 }
20294
20295 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 return SWIG_Python_InitShadowInstance(args);
20297 }
20298
20299 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxPCXHandler *result = 0 ;
20302
20303 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 result = (wxPCXHandler *)new wxPCXHandler();
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20318 PyObject *obj;
20319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20320 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20321 return SWIG_Py_Void();
20322 }
20323
20324 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 return SWIG_Python_InitShadowInstance(args);
20326 }
20327
20328 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 PyObject *resultobj = 0;
20330 wxJPEGHandler *result = 0 ;
20331
20332 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20333 {
20334 PyThreadState* __tstate = wxPyBeginAllowThreads();
20335 result = (wxJPEGHandler *)new wxJPEGHandler();
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20347 PyObject *obj;
20348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20349 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20350 return SWIG_Py_Void();
20351 }
20352
20353 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20354 return SWIG_Python_InitShadowInstance(args);
20355 }
20356
20357 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 PyObject *resultobj = 0;
20359 wxPNMHandler *result = 0 ;
20360
20361 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = (wxPNMHandler *)new wxPNMHandler();
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20376 PyObject *obj;
20377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20378 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20379 return SWIG_Py_Void();
20380 }
20381
20382 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20383 return SWIG_Python_InitShadowInstance(args);
20384 }
20385
20386 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 PyObject *resultobj = 0;
20388 wxXPMHandler *result = 0 ;
20389
20390 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20391 {
20392 PyThreadState* __tstate = wxPyBeginAllowThreads();
20393 result = (wxXPMHandler *)new wxXPMHandler();
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20405 PyObject *obj;
20406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20407 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20408 return SWIG_Py_Void();
20409 }
20410
20411 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 return SWIG_Python_InitShadowInstance(args);
20413 }
20414
20415 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxTIFFHandler *result = 0 ;
20418
20419 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20420 {
20421 PyThreadState* __tstate = wxPyBeginAllowThreads();
20422 result = (wxTIFFHandler *)new wxTIFFHandler();
20423 wxPyEndAllowThreads(__tstate);
20424 if (PyErr_Occurred()) SWIG_fail;
20425 }
20426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20434 PyObject *obj;
20435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20436 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20437 return SWIG_Py_Void();
20438 }
20439
20440 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20441 return SWIG_Python_InitShadowInstance(args);
20442 }
20443
20444 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20445 PyObject *resultobj = 0;
20446 wxImage *arg1 = 0 ;
20447 wxImage *arg2 = 0 ;
20448 int arg3 = (int) 236 ;
20449 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20450 bool result;
20451 void *argp1 = 0 ;
20452 int res1 = 0 ;
20453 void *argp2 = 0 ;
20454 int res2 = 0 ;
20455 int val3 ;
20456 int ecode3 = 0 ;
20457 int val4 ;
20458 int ecode4 = 0 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 PyObject * obj3 = 0 ;
20463 char * kwnames[] = {
20464 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20465 };
20466
20467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20468 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20469 if (!SWIG_IsOK(res1)) {
20470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20471 }
20472 if (!argp1) {
20473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20474 }
20475 arg1 = reinterpret_cast< wxImage * >(argp1);
20476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20477 if (!SWIG_IsOK(res2)) {
20478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20479 }
20480 if (!argp2) {
20481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20482 }
20483 arg2 = reinterpret_cast< wxImage * >(argp2);
20484 if (obj2) {
20485 ecode3 = SWIG_AsVal_int(obj2, &val3);
20486 if (!SWIG_IsOK(ecode3)) {
20487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20488 }
20489 arg3 = static_cast< int >(val3);
20490 }
20491 if (obj3) {
20492 ecode4 = SWIG_AsVal_int(obj3, &val4);
20493 if (!SWIG_IsOK(ecode4)) {
20494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20495 }
20496 arg4 = static_cast< int >(val4);
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *obj;
20515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20516 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20517 return SWIG_Py_Void();
20518 }
20519
20520 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20521 PyObject *resultobj = 0;
20522 wxEvtHandler *result = 0 ;
20523
20524 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 result = (wxEvtHandler *)new wxEvtHandler();
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20539 PyObject *resultobj = 0;
20540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20541 wxEvtHandler *result = 0 ;
20542 void *argp1 = 0 ;
20543 int res1 = 0 ;
20544 PyObject *swig_obj[1] ;
20545
20546 if (!args) SWIG_fail;
20547 swig_obj[0] = args;
20548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20551 }
20552 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 {
20560 resultobj = wxPyMake_wxObject(result, 0);
20561 }
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20569 PyObject *resultobj = 0;
20570 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20571 wxEvtHandler *result = 0 ;
20572 void *argp1 = 0 ;
20573 int res1 = 0 ;
20574 PyObject *swig_obj[1] ;
20575
20576 if (!args) SWIG_fail;
20577 swig_obj[0] = args;
20578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20579 if (!SWIG_IsOK(res1)) {
20580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20581 }
20582 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 {
20590 resultobj = wxPyMake_wxObject(result, 0);
20591 }
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20599 PyObject *resultobj = 0;
20600 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20601 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20602 void *argp1 = 0 ;
20603 int res1 = 0 ;
20604 void *argp2 = 0 ;
20605 int res2 = 0 ;
20606 PyObject * obj0 = 0 ;
20607 PyObject * obj1 = 0 ;
20608 char * kwnames[] = {
20609 (char *) "self",(char *) "handler", NULL
20610 };
20611
20612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20616 }
20617 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20619 if (!SWIG_IsOK(res2)) {
20620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20621 }
20622 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 (arg1)->SetNextHandler(arg2);
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 resultobj = SWIG_Py_Void();
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj = 0;
20638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20639 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20640 void *argp1 = 0 ;
20641 int res1 = 0 ;
20642 void *argp2 = 0 ;
20643 int res2 = 0 ;
20644 PyObject * obj0 = 0 ;
20645 PyObject * obj1 = 0 ;
20646 char * kwnames[] = {
20647 (char *) "self",(char *) "handler", NULL
20648 };
20649
20650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20657 if (!SWIG_IsOK(res2)) {
20658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20659 }
20660 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 (arg1)->SetPreviousHandler(arg2);
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 resultobj = SWIG_Py_Void();
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20675 PyObject *resultobj = 0;
20676 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20677 bool result;
20678 void *argp1 = 0 ;
20679 int res1 = 0 ;
20680 PyObject *swig_obj[1] ;
20681
20682 if (!args) SWIG_fail;
20683 swig_obj[0] = args;
20684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20687 }
20688 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (bool)(arg1)->GetEvtHandlerEnabled();
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 {
20696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20697 }
20698 return resultobj;
20699 fail:
20700 return NULL;
20701 }
20702
20703
20704 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20705 PyObject *resultobj = 0;
20706 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20707 bool arg2 ;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 bool val2 ;
20711 int ecode2 = 0 ;
20712 PyObject * obj0 = 0 ;
20713 PyObject * obj1 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "self",(char *) "enabled", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20722 }
20723 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20725 if (!SWIG_IsOK(ecode2)) {
20726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20727 }
20728 arg2 = static_cast< bool >(val2);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 (arg1)->SetEvtHandlerEnabled(arg2);
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 resultobj = SWIG_Py_Void();
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj = 0;
20744 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20745 wxEvent *arg2 = 0 ;
20746 bool result;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 void *argp2 = 0 ;
20750 int res2 = 0 ;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 char * kwnames[] = {
20754 (char *) "self",(char *) "event", NULL
20755 };
20756
20757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20759 if (!SWIG_IsOK(res1)) {
20760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20761 }
20762 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20764 if (!SWIG_IsOK(res2)) {
20765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20766 }
20767 if (!argp2) {
20768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20769 }
20770 arg2 = reinterpret_cast< wxEvent * >(argp2);
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (bool)(arg1)->ProcessEvent(*arg2);
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 {
20778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20779 }
20780 return resultobj;
20781 fail:
20782 return NULL;
20783 }
20784
20785
20786 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj = 0;
20788 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20789 wxEvent *arg2 = 0 ;
20790 void *argp1 = 0 ;
20791 int res1 = 0 ;
20792 void *argp2 = 0 ;
20793 int res2 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 PyObject * obj1 = 0 ;
20796 char * kwnames[] = {
20797 (char *) "self",(char *) "event", NULL
20798 };
20799
20800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20804 }
20805 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20807 if (!SWIG_IsOK(res2)) {
20808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20809 }
20810 if (!argp2) {
20811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20812 }
20813 arg2 = reinterpret_cast< wxEvent * >(argp2);
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 (arg1)->AddPendingEvent(*arg2);
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 resultobj = SWIG_Py_Void();
20821 return resultobj;
20822 fail:
20823 return NULL;
20824 }
20825
20826
20827 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20828 PyObject *resultobj = 0;
20829 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 PyObject *swig_obj[1] ;
20833
20834 if (!args) SWIG_fail;
20835 swig_obj[0] = args;
20836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20839 }
20840 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 (arg1)->ProcessPendingEvents();
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_Py_Void();
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj = 0;
20856 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20857 bool arg2 = (bool) true ;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 bool val2 ;
20861 int ecode2 = 0 ;
20862 PyObject * obj0 = 0 ;
20863 PyObject * obj1 = 0 ;
20864 char * kwnames[] = {
20865 (char *) "self",(char *) "allow", NULL
20866 };
20867
20868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20872 }
20873 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20874 if (obj1) {
20875 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20876 if (!SWIG_IsOK(ecode2)) {
20877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20878 }
20879 arg2 = static_cast< bool >(val2);
20880 }
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 (arg1)->AllowReentrance(arg2);
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 resultobj = SWIG_Py_Void();
20888 return resultobj;
20889 fail:
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20895 PyObject *resultobj = 0;
20896 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20897 bool result;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 PyObject *swig_obj[1] ;
20901
20902 if (!args) SWIG_fail;
20903 swig_obj[0] = args;
20904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20907 }
20908 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)(arg1)->IsReentranceAllowed();
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 {
20916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925 PyObject *resultobj = 0;
20926 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20927 bool result;
20928 void *argp1 = 0 ;
20929 int res1 = 0 ;
20930 PyObject *swig_obj[1] ;
20931
20932 if (!args) SWIG_fail;
20933 swig_obj[0] = args;
20934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20935 if (!SWIG_IsOK(res1)) {
20936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20937 }
20938 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (bool)(arg1)->IsEventHandlingInProgress();
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 {
20946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20947 }
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20955 PyObject *resultobj = 0;
20956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20957 int arg2 ;
20958 int arg3 ;
20959 int arg4 ;
20960 PyObject *arg5 = (PyObject *) 0 ;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 int val2 ;
20964 int ecode2 = 0 ;
20965 int val3 ;
20966 int ecode3 = 0 ;
20967 int val4 ;
20968 int ecode4 = 0 ;
20969 PyObject * obj0 = 0 ;
20970 PyObject * obj1 = 0 ;
20971 PyObject * obj2 = 0 ;
20972 PyObject * obj3 = 0 ;
20973 PyObject * obj4 = 0 ;
20974 char * kwnames[] = {
20975 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20976 };
20977
20978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20980 if (!SWIG_IsOK(res1)) {
20981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20982 }
20983 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20984 ecode2 = SWIG_AsVal_int(obj1, &val2);
20985 if (!SWIG_IsOK(ecode2)) {
20986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20987 }
20988 arg2 = static_cast< int >(val2);
20989 ecode3 = SWIG_AsVal_int(obj2, &val3);
20990 if (!SWIG_IsOK(ecode3)) {
20991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20992 }
20993 arg3 = static_cast< int >(val3);
20994 ecode4 = SWIG_AsVal_int(obj3, &val4);
20995 if (!SWIG_IsOK(ecode4)) {
20996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20997 }
20998 arg4 = static_cast< int >(val4);
20999 arg5 = obj4;
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_Py_Void();
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21014 PyObject *resultobj = 0;
21015 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21016 int arg2 ;
21017 int arg3 = (int) -1 ;
21018 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21019 bool result;
21020 void *argp1 = 0 ;
21021 int res1 = 0 ;
21022 int val2 ;
21023 int ecode2 = 0 ;
21024 int val3 ;
21025 int ecode3 = 0 ;
21026 int val4 ;
21027 int ecode4 = 0 ;
21028 PyObject * obj0 = 0 ;
21029 PyObject * obj1 = 0 ;
21030 PyObject * obj2 = 0 ;
21031 PyObject * obj3 = 0 ;
21032 char * kwnames[] = {
21033 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21034 };
21035
21036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21038 if (!SWIG_IsOK(res1)) {
21039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21040 }
21041 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21042 ecode2 = SWIG_AsVal_int(obj1, &val2);
21043 if (!SWIG_IsOK(ecode2)) {
21044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21045 }
21046 arg2 = static_cast< int >(val2);
21047 if (obj2) {
21048 ecode3 = SWIG_AsVal_int(obj2, &val3);
21049 if (!SWIG_IsOK(ecode3)) {
21050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21051 }
21052 arg3 = static_cast< int >(val3);
21053 }
21054 if (obj3) {
21055 ecode4 = SWIG_AsVal_int(obj3, &val4);
21056 if (!SWIG_IsOK(ecode4)) {
21057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21058 }
21059 arg4 = static_cast< wxEventType >(val4);
21060 }
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj = 0;
21078 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21079 PyObject *arg2 = (PyObject *) 0 ;
21080 bool arg3 = (bool) true ;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 bool val3 ;
21084 int ecode3 = 0 ;
21085 PyObject * obj0 = 0 ;
21086 PyObject * obj1 = 0 ;
21087 PyObject * obj2 = 0 ;
21088 char * kwnames[] = {
21089 (char *) "self",(char *) "_self",(char *) "incref", NULL
21090 };
21091
21092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21096 }
21097 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21098 arg2 = obj1;
21099 if (obj2) {
21100 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21101 if (!SWIG_IsOK(ecode3)) {
21102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21103 }
21104 arg3 = static_cast< bool >(val3);
21105 }
21106 {
21107 PyThreadState* __tstate = wxPyBeginAllowThreads();
21108 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 resultobj = SWIG_Py_Void();
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 PyObject *obj;
21121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21122 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21123 return SWIG_Py_Void();
21124 }
21125
21126 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 return SWIG_Python_InitShadowInstance(args);
21128 }
21129
21130 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxEventType result;
21133
21134 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = (wxEventType)wxNewEventType();
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 resultobj = SWIG_From_int(static_cast< int >(result));
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21149 PyObject *resultobj = 0;
21150 wxEvent *arg1 = (wxEvent *) 0 ;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21160 }
21161 arg1 = reinterpret_cast< wxEvent * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 delete arg1;
21165
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 resultobj = SWIG_Py_Void();
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj = 0;
21178 wxEvent *arg1 = (wxEvent *) 0 ;
21179 wxEventType arg2 ;
21180 void *argp1 = 0 ;
21181 int res1 = 0 ;
21182 int val2 ;
21183 int ecode2 = 0 ;
21184 PyObject * obj0 = 0 ;
21185 PyObject * obj1 = 0 ;
21186 char * kwnames[] = {
21187 (char *) "self",(char *) "typ", NULL
21188 };
21189
21190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21192 if (!SWIG_IsOK(res1)) {
21193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21194 }
21195 arg1 = reinterpret_cast< wxEvent * >(argp1);
21196 ecode2 = SWIG_AsVal_int(obj1, &val2);
21197 if (!SWIG_IsOK(ecode2)) {
21198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21199 }
21200 arg2 = static_cast< wxEventType >(val2);
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 (arg1)->SetEventType(arg2);
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 resultobj = SWIG_Py_Void();
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21215 PyObject *resultobj = 0;
21216 wxEvent *arg1 = (wxEvent *) 0 ;
21217 wxEventType result;
21218 void *argp1 = 0 ;
21219 int res1 = 0 ;
21220 PyObject *swig_obj[1] ;
21221
21222 if (!args) SWIG_fail;
21223 swig_obj[0] = args;
21224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21225 if (!SWIG_IsOK(res1)) {
21226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21227 }
21228 arg1 = reinterpret_cast< wxEvent * >(argp1);
21229 {
21230 PyThreadState* __tstate = wxPyBeginAllowThreads();
21231 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21232 wxPyEndAllowThreads(__tstate);
21233 if (PyErr_Occurred()) SWIG_fail;
21234 }
21235 resultobj = SWIG_From_int(static_cast< int >(result));
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxEvent *arg1 = (wxEvent *) 0 ;
21245 wxObject *result = 0 ;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 resultobj = wxPyMake_wxObject(result, (bool)0);
21265 }
21266 return resultobj;
21267 fail:
21268 return NULL;
21269 }
21270
21271
21272 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21273 PyObject *resultobj = 0;
21274 wxEvent *arg1 = (wxEvent *) 0 ;
21275 wxObject *arg2 = (wxObject *) 0 ;
21276 void *argp1 = 0 ;
21277 int res1 = 0 ;
21278 void *argp2 = 0 ;
21279 int res2 = 0 ;
21280 PyObject * obj0 = 0 ;
21281 PyObject * obj1 = 0 ;
21282 char * kwnames[] = {
21283 (char *) "self",(char *) "obj", NULL
21284 };
21285
21286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxEvent * >(argp1);
21292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21293 if (!SWIG_IsOK(res2)) {
21294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21295 }
21296 arg2 = reinterpret_cast< wxObject * >(argp2);
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 (arg1)->SetEventObject(arg2);
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 resultobj = SWIG_Py_Void();
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *resultobj = 0;
21312 wxEvent *arg1 = (wxEvent *) 0 ;
21313 long result;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 PyObject *swig_obj[1] ;
21317
21318 if (!args) SWIG_fail;
21319 swig_obj[0] = args;
21320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21321 if (!SWIG_IsOK(res1)) {
21322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21323 }
21324 arg1 = reinterpret_cast< wxEvent * >(argp1);
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21328 wxPyEndAllowThreads(__tstate);
21329 if (PyErr_Occurred()) SWIG_fail;
21330 }
21331 resultobj = SWIG_From_long(static_cast< long >(result));
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21339 PyObject *resultobj = 0;
21340 wxEvent *arg1 = (wxEvent *) 0 ;
21341 long arg2 = (long) 0 ;
21342 void *argp1 = 0 ;
21343 int res1 = 0 ;
21344 long val2 ;
21345 int ecode2 = 0 ;
21346 PyObject * obj0 = 0 ;
21347 PyObject * obj1 = 0 ;
21348 char * kwnames[] = {
21349 (char *) "self",(char *) "ts", NULL
21350 };
21351
21352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxEvent * >(argp1);
21358 if (obj1) {
21359 ecode2 = SWIG_AsVal_long(obj1, &val2);
21360 if (!SWIG_IsOK(ecode2)) {
21361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21362 }
21363 arg2 = static_cast< long >(val2);
21364 }
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 (arg1)->SetTimestamp(arg2);
21368 wxPyEndAllowThreads(__tstate);
21369 if (PyErr_Occurred()) SWIG_fail;
21370 }
21371 resultobj = SWIG_Py_Void();
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 PyObject *resultobj = 0;
21380 wxEvent *arg1 = (wxEvent *) 0 ;
21381 int result;
21382 void *argp1 = 0 ;
21383 int res1 = 0 ;
21384 PyObject *swig_obj[1] ;
21385
21386 if (!args) SWIG_fail;
21387 swig_obj[0] = args;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21391 }
21392 arg1 = reinterpret_cast< wxEvent * >(argp1);
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 result = (int)((wxEvent const *)arg1)->GetId();
21396 wxPyEndAllowThreads(__tstate);
21397 if (PyErr_Occurred()) SWIG_fail;
21398 }
21399 resultobj = SWIG_From_int(static_cast< int >(result));
21400 return resultobj;
21401 fail:
21402 return NULL;
21403 }
21404
21405
21406 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21407 PyObject *resultobj = 0;
21408 wxEvent *arg1 = (wxEvent *) 0 ;
21409 int arg2 ;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 int val2 ;
21413 int ecode2 = 0 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char * kwnames[] = {
21417 (char *) "self",(char *) "Id", NULL
21418 };
21419
21420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21422 if (!SWIG_IsOK(res1)) {
21423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21424 }
21425 arg1 = reinterpret_cast< wxEvent * >(argp1);
21426 ecode2 = SWIG_AsVal_int(obj1, &val2);
21427 if (!SWIG_IsOK(ecode2)) {
21428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21429 }
21430 arg2 = static_cast< int >(val2);
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 (arg1)->SetId(arg2);
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 resultobj = SWIG_Py_Void();
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21445 PyObject *resultobj = 0;
21446 wxEvent *arg1 = (wxEvent *) 0 ;
21447 bool result;
21448 void *argp1 = 0 ;
21449 int res1 = 0 ;
21450 PyObject *swig_obj[1] ;
21451
21452 if (!args) SWIG_fail;
21453 swig_obj[0] = args;
21454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21457 }
21458 arg1 = reinterpret_cast< wxEvent * >(argp1);
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 {
21466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21467 }
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj = 0;
21476 wxEvent *arg1 = (wxEvent *) 0 ;
21477 bool arg2 = (bool) true ;
21478 void *argp1 = 0 ;
21479 int res1 = 0 ;
21480 bool val2 ;
21481 int ecode2 = 0 ;
21482 PyObject * obj0 = 0 ;
21483 PyObject * obj1 = 0 ;
21484 char * kwnames[] = {
21485 (char *) "self",(char *) "skip", NULL
21486 };
21487
21488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21490 if (!SWIG_IsOK(res1)) {
21491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21492 }
21493 arg1 = reinterpret_cast< wxEvent * >(argp1);
21494 if (obj1) {
21495 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21496 if (!SWIG_IsOK(ecode2)) {
21497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21498 }
21499 arg2 = static_cast< bool >(val2);
21500 }
21501 {
21502 PyThreadState* __tstate = wxPyBeginAllowThreads();
21503 (arg1)->Skip(arg2);
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 resultobj = SWIG_Py_Void();
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21515 PyObject *resultobj = 0;
21516 wxEvent *arg1 = (wxEvent *) 0 ;
21517 bool result;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 PyObject *swig_obj[1] ;
21521
21522 if (!args) SWIG_fail;
21523 swig_obj[0] = args;
21524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21525 if (!SWIG_IsOK(res1)) {
21526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21527 }
21528 arg1 = reinterpret_cast< wxEvent * >(argp1);
21529 {
21530 PyThreadState* __tstate = wxPyBeginAllowThreads();
21531 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21532 wxPyEndAllowThreads(__tstate);
21533 if (PyErr_Occurred()) SWIG_fail;
21534 }
21535 {
21536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21537 }
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21545 PyObject *resultobj = 0;
21546 wxEvent *arg1 = (wxEvent *) 0 ;
21547 bool result;
21548 void *argp1 = 0 ;
21549 int res1 = 0 ;
21550 PyObject *swig_obj[1] ;
21551
21552 if (!args) SWIG_fail;
21553 swig_obj[0] = args;
21554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21555 if (!SWIG_IsOK(res1)) {
21556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21557 }
21558 arg1 = reinterpret_cast< wxEvent * >(argp1);
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21562 wxPyEndAllowThreads(__tstate);
21563 if (PyErr_Occurred()) SWIG_fail;
21564 }
21565 {
21566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21567 }
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21575 PyObject *resultobj = 0;
21576 wxEvent *arg1 = (wxEvent *) 0 ;
21577 int result;
21578 void *argp1 = 0 ;
21579 int res1 = 0 ;
21580 PyObject *swig_obj[1] ;
21581
21582 if (!args) SWIG_fail;
21583 swig_obj[0] = args;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21587 }
21588 arg1 = reinterpret_cast< wxEvent * >(argp1);
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 result = (int)(arg1)->StopPropagation();
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 resultobj = SWIG_From_int(static_cast< int >(result));
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21603 PyObject *resultobj = 0;
21604 wxEvent *arg1 = (wxEvent *) 0 ;
21605 int arg2 ;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 int val2 ;
21609 int ecode2 = 0 ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 char * kwnames[] = {
21613 (char *) "self",(char *) "propagationLevel", NULL
21614 };
21615
21616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxEvent * >(argp1);
21622 ecode2 = SWIG_AsVal_int(obj1, &val2);
21623 if (!SWIG_IsOK(ecode2)) {
21624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21625 }
21626 arg2 = static_cast< int >(val2);
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 (arg1)->ResumePropagation(arg2);
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 resultobj = SWIG_Py_Void();
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 PyObject *resultobj = 0;
21642 wxEvent *arg1 = (wxEvent *) 0 ;
21643 wxEvent *result = 0 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 PyObject *swig_obj[1] ;
21647
21648 if (!args) SWIG_fail;
21649 swig_obj[0] = args;
21650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21651 if (!SWIG_IsOK(res1)) {
21652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21653 }
21654 arg1 = reinterpret_cast< wxEvent * >(argp1);
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 result = (wxEvent *)(arg1)->Clone();
21658 wxPyEndAllowThreads(__tstate);
21659 if (PyErr_Occurred()) SWIG_fail;
21660 }
21661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *obj;
21670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21671 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21672 return SWIG_Py_Void();
21673 }
21674
21675 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21676 PyObject *resultobj = 0;
21677 wxEvent *arg1 = 0 ;
21678 wxPropagationDisabler *result = 0 ;
21679 void *argp1 = 0 ;
21680 int res1 = 0 ;
21681 PyObject * obj0 = 0 ;
21682 char * kwnames[] = {
21683 (char *) "event", NULL
21684 };
21685
21686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21687 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21688 if (!SWIG_IsOK(res1)) {
21689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21690 }
21691 if (!argp1) {
21692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21693 }
21694 arg1 = reinterpret_cast< wxEvent * >(argp1);
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709 PyObject *resultobj = 0;
21710 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21711 void *argp1 = 0 ;
21712 int res1 = 0 ;
21713 PyObject *swig_obj[1] ;
21714
21715 if (!args) SWIG_fail;
21716 swig_obj[0] = args;
21717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21718 if (!SWIG_IsOK(res1)) {
21719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21720 }
21721 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 delete arg1;
21725
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 resultobj = SWIG_Py_Void();
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21737 PyObject *obj;
21738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21739 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21740 return SWIG_Py_Void();
21741 }
21742
21743 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21744 return SWIG_Python_InitShadowInstance(args);
21745 }
21746
21747 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21748 PyObject *resultobj = 0;
21749 wxEvent *arg1 = 0 ;
21750 wxPropagateOnce *result = 0 ;
21751 void *argp1 = 0 ;
21752 int res1 = 0 ;
21753 PyObject * obj0 = 0 ;
21754 char * kwnames[] = {
21755 (char *) "event", NULL
21756 };
21757
21758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21759 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21760 if (!SWIG_IsOK(res1)) {
21761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21762 }
21763 if (!argp1) {
21764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21765 }
21766 arg1 = reinterpret_cast< wxEvent * >(argp1);
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21792 }
21793 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 delete arg1;
21797
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 resultobj = SWIG_Py_Void();
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21809 PyObject *obj;
21810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21811 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21812 return SWIG_Py_Void();
21813 }
21814
21815 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21816 return SWIG_Python_InitShadowInstance(args);
21817 }
21818
21819 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21820 PyObject *resultobj = 0;
21821 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21822 int arg2 = (int) 0 ;
21823 wxCommandEvent *result = 0 ;
21824 int val1 ;
21825 int ecode1 = 0 ;
21826 int val2 ;
21827 int ecode2 = 0 ;
21828 PyObject * obj0 = 0 ;
21829 PyObject * obj1 = 0 ;
21830 char * kwnames[] = {
21831 (char *) "commandType",(char *) "winid", NULL
21832 };
21833
21834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21835 if (obj0) {
21836 ecode1 = SWIG_AsVal_int(obj0, &val1);
21837 if (!SWIG_IsOK(ecode1)) {
21838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21839 }
21840 arg1 = static_cast< wxEventType >(val1);
21841 }
21842 if (obj1) {
21843 ecode2 = SWIG_AsVal_int(obj1, &val2);
21844 if (!SWIG_IsOK(ecode2)) {
21845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21846 }
21847 arg2 = static_cast< int >(val2);
21848 }
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21852 wxPyEndAllowThreads(__tstate);
21853 if (PyErr_Occurred()) SWIG_fail;
21854 }
21855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *resultobj = 0;
21864 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21865 int result;
21866 void *argp1 = 0 ;
21867 int res1 = 0 ;
21868 PyObject *swig_obj[1] ;
21869
21870 if (!args) SWIG_fail;
21871 swig_obj[0] = args;
21872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21873 if (!SWIG_IsOK(res1)) {
21874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21875 }
21876 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21877 {
21878 PyThreadState* __tstate = wxPyBeginAllowThreads();
21879 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21880 wxPyEndAllowThreads(__tstate);
21881 if (PyErr_Occurred()) SWIG_fail;
21882 }
21883 resultobj = SWIG_From_int(static_cast< int >(result));
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21891 PyObject *resultobj = 0;
21892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21893 wxString *arg2 = 0 ;
21894 void *argp1 = 0 ;
21895 int res1 = 0 ;
21896 bool temp2 = false ;
21897 PyObject * obj0 = 0 ;
21898 PyObject * obj1 = 0 ;
21899 char * kwnames[] = {
21900 (char *) "self",(char *) "s", NULL
21901 };
21902
21903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21905 if (!SWIG_IsOK(res1)) {
21906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21907 }
21908 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21909 {
21910 arg2 = wxString_in_helper(obj1);
21911 if (arg2 == NULL) SWIG_fail;
21912 temp2 = true;
21913 }
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 (arg1)->SetString((wxString const &)*arg2);
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 resultobj = SWIG_Py_Void();
21921 {
21922 if (temp2)
21923 delete arg2;
21924 }
21925 return resultobj;
21926 fail:
21927 {
21928 if (temp2)
21929 delete arg2;
21930 }
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21936 PyObject *resultobj = 0;
21937 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21938 wxString result;
21939 void *argp1 = 0 ;
21940 int res1 = 0 ;
21941 PyObject *swig_obj[1] ;
21942
21943 if (!args) SWIG_fail;
21944 swig_obj[0] = args;
21945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21946 if (!SWIG_IsOK(res1)) {
21947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21948 }
21949 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 result = ((wxCommandEvent const *)arg1)->GetString();
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 {
21957 #if wxUSE_UNICODE
21958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21959 #else
21960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21961 #endif
21962 }
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21970 PyObject *resultobj = 0;
21971 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21972 bool result;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 PyObject *swig_obj[1] ;
21976
21977 if (!args) SWIG_fail;
21978 swig_obj[0] = args;
21979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21982 }
21983 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 {
21991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21992 }
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22002 bool result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 {
22021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22022 }
22023 return resultobj;
22024 fail:
22025 return NULL;
22026 }
22027
22028
22029 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22030 PyObject *resultobj = 0;
22031 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22032 long arg2 ;
22033 void *argp1 = 0 ;
22034 int res1 = 0 ;
22035 long val2 ;
22036 int ecode2 = 0 ;
22037 PyObject * obj0 = 0 ;
22038 PyObject * obj1 = 0 ;
22039 char * kwnames[] = {
22040 (char *) "self",(char *) "extraLong", NULL
22041 };
22042
22043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22045 if (!SWIG_IsOK(res1)) {
22046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22047 }
22048 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22049 ecode2 = SWIG_AsVal_long(obj1, &val2);
22050 if (!SWIG_IsOK(ecode2)) {
22051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22052 }
22053 arg2 = static_cast< long >(val2);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 (arg1)->SetExtraLong(arg2);
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 resultobj = SWIG_Py_Void();
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22068 PyObject *resultobj = 0;
22069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22070 long result;
22071 void *argp1 = 0 ;
22072 int res1 = 0 ;
22073 PyObject *swig_obj[1] ;
22074
22075 if (!args) SWIG_fail;
22076 swig_obj[0] = args;
22077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22078 if (!SWIG_IsOK(res1)) {
22079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22080 }
22081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22082 {
22083 PyThreadState* __tstate = wxPyBeginAllowThreads();
22084 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 resultobj = SWIG_From_long(static_cast< long >(result));
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22096 PyObject *resultobj = 0;
22097 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22098 int arg2 ;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 int val2 ;
22102 int ecode2 = 0 ;
22103 PyObject * obj0 = 0 ;
22104 PyObject * obj1 = 0 ;
22105 char * kwnames[] = {
22106 (char *) "self",(char *) "i", NULL
22107 };
22108
22109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22111 if (!SWIG_IsOK(res1)) {
22112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22113 }
22114 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22115 ecode2 = SWIG_AsVal_int(obj1, &val2);
22116 if (!SWIG_IsOK(ecode2)) {
22117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22118 }
22119 arg2 = static_cast< int >(val2);
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 (arg1)->SetInt(arg2);
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 resultobj = SWIG_Py_Void();
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22134 PyObject *resultobj = 0;
22135 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22136 int result;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 PyObject *swig_obj[1] ;
22140
22141 if (!args) SWIG_fail;
22142 swig_obj[0] = args;
22143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22146 }
22147 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 resultobj = SWIG_From_int(static_cast< int >(result));
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *resultobj = 0;
22163 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22164 PyObject *result = 0 ;
22165 void *argp1 = 0 ;
22166 int res1 = 0 ;
22167 PyObject *swig_obj[1] ;
22168
22169 if (!args) SWIG_fail;
22170 swig_obj[0] = args;
22171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22174 }
22175 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = result;
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj = 0;
22191 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22192 PyObject *arg2 = (PyObject *) 0 ;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject * obj0 = 0 ;
22196 PyObject * obj1 = 0 ;
22197 char * kwnames[] = {
22198 (char *) "self",(char *) "clientData", NULL
22199 };
22200
22201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22205 }
22206 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22207 arg2 = obj1;
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 wxCommandEvent_SetClientData(arg1,arg2);
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 resultobj = SWIG_Py_Void();
22215 return resultobj;
22216 fail:
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22222 PyObject *resultobj = 0;
22223 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22224 wxEvent *result = 0 ;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 PyObject *swig_obj[1] ;
22228
22229 if (!args) SWIG_fail;
22230 swig_obj[0] = args;
22231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22234 }
22235 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *obj;
22251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22252 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22253 return SWIG_Py_Void();
22254 }
22255
22256 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22257 return SWIG_Python_InitShadowInstance(args);
22258 }
22259
22260 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22261 PyObject *resultobj = 0;
22262 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22263 int arg2 = (int) 0 ;
22264 wxNotifyEvent *result = 0 ;
22265 int val1 ;
22266 int ecode1 = 0 ;
22267 int val2 ;
22268 int ecode2 = 0 ;
22269 PyObject * obj0 = 0 ;
22270 PyObject * obj1 = 0 ;
22271 char * kwnames[] = {
22272 (char *) "commandType",(char *) "winid", NULL
22273 };
22274
22275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22276 if (obj0) {
22277 ecode1 = SWIG_AsVal_int(obj0, &val1);
22278 if (!SWIG_IsOK(ecode1)) {
22279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22280 }
22281 arg1 = static_cast< wxEventType >(val1);
22282 }
22283 if (obj1) {
22284 ecode2 = SWIG_AsVal_int(obj1, &val2);
22285 if (!SWIG_IsOK(ecode2)) {
22286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22287 }
22288 arg2 = static_cast< int >(val2);
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22304 PyObject *resultobj = 0;
22305 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22306 void *argp1 = 0 ;
22307 int res1 = 0 ;
22308 PyObject *swig_obj[1] ;
22309
22310 if (!args) SWIG_fail;
22311 swig_obj[0] = args;
22312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22313 if (!SWIG_IsOK(res1)) {
22314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22315 }
22316 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 (arg1)->Veto();
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 resultobj = SWIG_Py_Void();
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22331 PyObject *resultobj = 0;
22332 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22342 }
22343 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 (arg1)->Allow();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_Py_Void();
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22358 PyObject *resultobj = 0;
22359 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22360 bool result;
22361 void *argp1 = 0 ;
22362 int res1 = 0 ;
22363 PyObject *swig_obj[1] ;
22364
22365 if (!args) SWIG_fail;
22366 swig_obj[0] = args;
22367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22368 if (!SWIG_IsOK(res1)) {
22369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22370 }
22371 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (bool)(arg1)->IsAllowed();
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 {
22379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22380 }
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *obj;
22389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22390 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22391 return SWIG_Py_Void();
22392 }
22393
22394 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22395 return SWIG_Python_InitShadowInstance(args);
22396 }
22397
22398 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22399 PyObject *resultobj = 0;
22400 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22401 int arg2 = (int) 0 ;
22402 int arg3 = (int) 0 ;
22403 int arg4 = (int) 0 ;
22404 wxScrollEvent *result = 0 ;
22405 int val1 ;
22406 int ecode1 = 0 ;
22407 int val2 ;
22408 int ecode2 = 0 ;
22409 int val3 ;
22410 int ecode3 = 0 ;
22411 int val4 ;
22412 int ecode4 = 0 ;
22413 PyObject * obj0 = 0 ;
22414 PyObject * obj1 = 0 ;
22415 PyObject * obj2 = 0 ;
22416 PyObject * obj3 = 0 ;
22417 char * kwnames[] = {
22418 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22419 };
22420
22421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22422 if (obj0) {
22423 ecode1 = SWIG_AsVal_int(obj0, &val1);
22424 if (!SWIG_IsOK(ecode1)) {
22425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22426 }
22427 arg1 = static_cast< wxEventType >(val1);
22428 }
22429 if (obj1) {
22430 ecode2 = SWIG_AsVal_int(obj1, &val2);
22431 if (!SWIG_IsOK(ecode2)) {
22432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22433 }
22434 arg2 = static_cast< int >(val2);
22435 }
22436 if (obj2) {
22437 ecode3 = SWIG_AsVal_int(obj2, &val3);
22438 if (!SWIG_IsOK(ecode3)) {
22439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22440 }
22441 arg3 = static_cast< int >(val3);
22442 }
22443 if (obj3) {
22444 ecode4 = SWIG_AsVal_int(obj3, &val4);
22445 if (!SWIG_IsOK(ecode4)) {
22446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22447 }
22448 arg4 = static_cast< int >(val4);
22449 }
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22464 PyObject *resultobj = 0;
22465 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22466 int result;
22467 void *argp1 = 0 ;
22468 int res1 = 0 ;
22469 PyObject *swig_obj[1] ;
22470
22471 if (!args) SWIG_fail;
22472 swig_obj[0] = args;
22473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22474 if (!SWIG_IsOK(res1)) {
22475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22476 }
22477 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22481 wxPyEndAllowThreads(__tstate);
22482 if (PyErr_Occurred()) SWIG_fail;
22483 }
22484 resultobj = SWIG_From_int(static_cast< int >(result));
22485 return resultobj;
22486 fail:
22487 return NULL;
22488 }
22489
22490
22491 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22492 PyObject *resultobj = 0;
22493 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22494 int result;
22495 void *argp1 = 0 ;
22496 int res1 = 0 ;
22497 PyObject *swig_obj[1] ;
22498
22499 if (!args) SWIG_fail;
22500 swig_obj[0] = args;
22501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22502 if (!SWIG_IsOK(res1)) {
22503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22504 }
22505 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22509 wxPyEndAllowThreads(__tstate);
22510 if (PyErr_Occurred()) SWIG_fail;
22511 }
22512 resultobj = SWIG_From_int(static_cast< int >(result));
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22520 PyObject *resultobj = 0;
22521 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22522 int arg2 ;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 int val2 ;
22526 int ecode2 = 0 ;
22527 PyObject * obj0 = 0 ;
22528 PyObject * obj1 = 0 ;
22529 char * kwnames[] = {
22530 (char *) "self",(char *) "orient", NULL
22531 };
22532
22533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22539 ecode2 = SWIG_AsVal_int(obj1, &val2);
22540 if (!SWIG_IsOK(ecode2)) {
22541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22542 }
22543 arg2 = static_cast< int >(val2);
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 (arg1)->SetOrientation(arg2);
22547 wxPyEndAllowThreads(__tstate);
22548 if (PyErr_Occurred()) SWIG_fail;
22549 }
22550 resultobj = SWIG_Py_Void();
22551 return resultobj;
22552 fail:
22553 return NULL;
22554 }
22555
22556
22557 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22558 PyObject *resultobj = 0;
22559 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22560 int arg2 ;
22561 void *argp1 = 0 ;
22562 int res1 = 0 ;
22563 int val2 ;
22564 int ecode2 = 0 ;
22565 PyObject * obj0 = 0 ;
22566 PyObject * obj1 = 0 ;
22567 char * kwnames[] = {
22568 (char *) "self",(char *) "pos", NULL
22569 };
22570
22571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22573 if (!SWIG_IsOK(res1)) {
22574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22575 }
22576 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22577 ecode2 = SWIG_AsVal_int(obj1, &val2);
22578 if (!SWIG_IsOK(ecode2)) {
22579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22580 }
22581 arg2 = static_cast< int >(val2);
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 (arg1)->SetPosition(arg2);
22585 wxPyEndAllowThreads(__tstate);
22586 if (PyErr_Occurred()) SWIG_fail;
22587 }
22588 resultobj = SWIG_Py_Void();
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *obj;
22597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22598 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22599 return SWIG_Py_Void();
22600 }
22601
22602 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22603 return SWIG_Python_InitShadowInstance(args);
22604 }
22605
22606 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22607 PyObject *resultobj = 0;
22608 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22609 int arg2 = (int) 0 ;
22610 int arg3 = (int) 0 ;
22611 wxScrollWinEvent *result = 0 ;
22612 int val1 ;
22613 int ecode1 = 0 ;
22614 int val2 ;
22615 int ecode2 = 0 ;
22616 int val3 ;
22617 int ecode3 = 0 ;
22618 PyObject * obj0 = 0 ;
22619 PyObject * obj1 = 0 ;
22620 PyObject * obj2 = 0 ;
22621 char * kwnames[] = {
22622 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22623 };
22624
22625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22626 if (obj0) {
22627 ecode1 = SWIG_AsVal_int(obj0, &val1);
22628 if (!SWIG_IsOK(ecode1)) {
22629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22630 }
22631 arg1 = static_cast< wxEventType >(val1);
22632 }
22633 if (obj1) {
22634 ecode2 = SWIG_AsVal_int(obj1, &val2);
22635 if (!SWIG_IsOK(ecode2)) {
22636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22637 }
22638 arg2 = static_cast< int >(val2);
22639 }
22640 if (obj2) {
22641 ecode3 = SWIG_AsVal_int(obj2, &val3);
22642 if (!SWIG_IsOK(ecode3)) {
22643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22644 }
22645 arg3 = static_cast< int >(val3);
22646 }
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22661 PyObject *resultobj = 0;
22662 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22663 int result;
22664 void *argp1 = 0 ;
22665 int res1 = 0 ;
22666 PyObject *swig_obj[1] ;
22667
22668 if (!args) SWIG_fail;
22669 swig_obj[0] = args;
22670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22671 if (!SWIG_IsOK(res1)) {
22672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22673 }
22674 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22678 wxPyEndAllowThreads(__tstate);
22679 if (PyErr_Occurred()) SWIG_fail;
22680 }
22681 resultobj = SWIG_From_int(static_cast< int >(result));
22682 return resultobj;
22683 fail:
22684 return NULL;
22685 }
22686
22687
22688 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22689 PyObject *resultobj = 0;
22690 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22691 int result;
22692 void *argp1 = 0 ;
22693 int res1 = 0 ;
22694 PyObject *swig_obj[1] ;
22695
22696 if (!args) SWIG_fail;
22697 swig_obj[0] = args;
22698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22699 if (!SWIG_IsOK(res1)) {
22700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22701 }
22702 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22706 wxPyEndAllowThreads(__tstate);
22707 if (PyErr_Occurred()) SWIG_fail;
22708 }
22709 resultobj = SWIG_From_int(static_cast< int >(result));
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22717 PyObject *resultobj = 0;
22718 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22719 int arg2 ;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 int val2 ;
22723 int ecode2 = 0 ;
22724 PyObject * obj0 = 0 ;
22725 PyObject * obj1 = 0 ;
22726 char * kwnames[] = {
22727 (char *) "self",(char *) "orient", NULL
22728 };
22729
22730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22732 if (!SWIG_IsOK(res1)) {
22733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22734 }
22735 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22736 ecode2 = SWIG_AsVal_int(obj1, &val2);
22737 if (!SWIG_IsOK(ecode2)) {
22738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22739 }
22740 arg2 = static_cast< int >(val2);
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 (arg1)->SetOrientation(arg2);
22744 wxPyEndAllowThreads(__tstate);
22745 if (PyErr_Occurred()) SWIG_fail;
22746 }
22747 resultobj = SWIG_Py_Void();
22748 return resultobj;
22749 fail:
22750 return NULL;
22751 }
22752
22753
22754 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22755 PyObject *resultobj = 0;
22756 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22757 int arg2 ;
22758 void *argp1 = 0 ;
22759 int res1 = 0 ;
22760 int val2 ;
22761 int ecode2 = 0 ;
22762 PyObject * obj0 = 0 ;
22763 PyObject * obj1 = 0 ;
22764 char * kwnames[] = {
22765 (char *) "self",(char *) "pos", NULL
22766 };
22767
22768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22770 if (!SWIG_IsOK(res1)) {
22771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22772 }
22773 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22774 ecode2 = SWIG_AsVal_int(obj1, &val2);
22775 if (!SWIG_IsOK(ecode2)) {
22776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22777 }
22778 arg2 = static_cast< int >(val2);
22779 {
22780 PyThreadState* __tstate = wxPyBeginAllowThreads();
22781 (arg1)->SetPosition(arg2);
22782 wxPyEndAllowThreads(__tstate);
22783 if (PyErr_Occurred()) SWIG_fail;
22784 }
22785 resultobj = SWIG_Py_Void();
22786 return resultobj;
22787 fail:
22788 return NULL;
22789 }
22790
22791
22792 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22793 PyObject *obj;
22794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22795 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22796 return SWIG_Py_Void();
22797 }
22798
22799 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800 return SWIG_Python_InitShadowInstance(args);
22801 }
22802
22803 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22804 PyObject *resultobj = 0;
22805 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22806 wxMouseEvent *result = 0 ;
22807 int val1 ;
22808 int ecode1 = 0 ;
22809 PyObject * obj0 = 0 ;
22810 char * kwnames[] = {
22811 (char *) "mouseType", NULL
22812 };
22813
22814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22815 if (obj0) {
22816 ecode1 = SWIG_AsVal_int(obj0, &val1);
22817 if (!SWIG_IsOK(ecode1)) {
22818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22819 }
22820 arg1 = static_cast< wxEventType >(val1);
22821 }
22822 {
22823 PyThreadState* __tstate = wxPyBeginAllowThreads();
22824 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22825 wxPyEndAllowThreads(__tstate);
22826 if (PyErr_Occurred()) SWIG_fail;
22827 }
22828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22829 return resultobj;
22830 fail:
22831 return NULL;
22832 }
22833
22834
22835 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22836 PyObject *resultobj = 0;
22837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22838 bool result;
22839 void *argp1 = 0 ;
22840 int res1 = 0 ;
22841 PyObject *swig_obj[1] ;
22842
22843 if (!args) SWIG_fail;
22844 swig_obj[0] = args;
22845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22846 if (!SWIG_IsOK(res1)) {
22847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22848 }
22849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22850 {
22851 PyThreadState* __tstate = wxPyBeginAllowThreads();
22852 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 {
22857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22858 }
22859 return resultobj;
22860 fail:
22861 return NULL;
22862 }
22863
22864
22865 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22866 PyObject *resultobj = 0;
22867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22868 int arg2 = (int) wxMOUSE_BTN_ANY ;
22869 bool result;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 int val2 ;
22873 int ecode2 = 0 ;
22874 PyObject * obj0 = 0 ;
22875 PyObject * obj1 = 0 ;
22876 char * kwnames[] = {
22877 (char *) "self",(char *) "but", NULL
22878 };
22879
22880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22882 if (!SWIG_IsOK(res1)) {
22883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22884 }
22885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22886 if (obj1) {
22887 ecode2 = SWIG_AsVal_int(obj1, &val2);
22888 if (!SWIG_IsOK(ecode2)) {
22889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22890 }
22891 arg2 = static_cast< int >(val2);
22892 }
22893 {
22894 PyThreadState* __tstate = wxPyBeginAllowThreads();
22895 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22896 wxPyEndAllowThreads(__tstate);
22897 if (PyErr_Occurred()) SWIG_fail;
22898 }
22899 {
22900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22901 }
22902 return resultobj;
22903 fail:
22904 return NULL;
22905 }
22906
22907
22908 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22909 PyObject *resultobj = 0;
22910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22911 int arg2 = (int) wxMOUSE_BTN_ANY ;
22912 bool result;
22913 void *argp1 = 0 ;
22914 int res1 = 0 ;
22915 int val2 ;
22916 int ecode2 = 0 ;
22917 PyObject * obj0 = 0 ;
22918 PyObject * obj1 = 0 ;
22919 char * kwnames[] = {
22920 (char *) "self",(char *) "but", NULL
22921 };
22922
22923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22925 if (!SWIG_IsOK(res1)) {
22926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22927 }
22928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22929 if (obj1) {
22930 ecode2 = SWIG_AsVal_int(obj1, &val2);
22931 if (!SWIG_IsOK(ecode2)) {
22932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22933 }
22934 arg2 = static_cast< int >(val2);
22935 }
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22944 }
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22952 PyObject *resultobj = 0;
22953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22954 int arg2 = (int) wxMOUSE_BTN_ANY ;
22955 bool result;
22956 void *argp1 = 0 ;
22957 int res1 = 0 ;
22958 int val2 ;
22959 int ecode2 = 0 ;
22960 PyObject * obj0 = 0 ;
22961 PyObject * obj1 = 0 ;
22962 char * kwnames[] = {
22963 (char *) "self",(char *) "but", NULL
22964 };
22965
22966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22968 if (!SWIG_IsOK(res1)) {
22969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22970 }
22971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22972 if (obj1) {
22973 ecode2 = SWIG_AsVal_int(obj1, &val2);
22974 if (!SWIG_IsOK(ecode2)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22976 }
22977 arg2 = static_cast< int >(val2);
22978 }
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22982 wxPyEndAllowThreads(__tstate);
22983 if (PyErr_Occurred()) SWIG_fail;
22984 }
22985 {
22986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22987 }
22988 return resultobj;
22989 fail:
22990 return NULL;
22991 }
22992
22993
22994 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22995 PyObject *resultobj = 0;
22996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22997 int arg2 ;
22998 bool result;
22999 void *argp1 = 0 ;
23000 int res1 = 0 ;
23001 int val2 ;
23002 int ecode2 = 0 ;
23003 PyObject * obj0 = 0 ;
23004 PyObject * obj1 = 0 ;
23005 char * kwnames[] = {
23006 (char *) "self",(char *) "button", NULL
23007 };
23008
23009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23011 if (!SWIG_IsOK(res1)) {
23012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23013 }
23014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23015 ecode2 = SWIG_AsVal_int(obj1, &val2);
23016 if (!SWIG_IsOK(ecode2)) {
23017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23018 }
23019 arg2 = static_cast< int >(val2);
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 {
23027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23028 }
23029 return resultobj;
23030 fail:
23031 return NULL;
23032 }
23033
23034
23035 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23036 PyObject *resultobj = 0;
23037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23038 int arg2 ;
23039 bool result;
23040 void *argp1 = 0 ;
23041 int res1 = 0 ;
23042 int val2 ;
23043 int ecode2 = 0 ;
23044 PyObject * obj0 = 0 ;
23045 PyObject * obj1 = 0 ;
23046 char * kwnames[] = {
23047 (char *) "self",(char *) "but", NULL
23048 };
23049
23050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23052 if (!SWIG_IsOK(res1)) {
23053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23054 }
23055 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23056 ecode2 = SWIG_AsVal_int(obj1, &val2);
23057 if (!SWIG_IsOK(ecode2)) {
23058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23059 }
23060 arg2 = static_cast< int >(val2);
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 {
23068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23069 }
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23077 PyObject *resultobj = 0;
23078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23079 int result;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 PyObject *swig_obj[1] ;
23083
23084 if (!args) SWIG_fail;
23085 swig_obj[0] = args;
23086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23087 if (!SWIG_IsOK(res1)) {
23088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23089 }
23090 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23091 {
23092 PyThreadState* __tstate = wxPyBeginAllowThreads();
23093 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23094 wxPyEndAllowThreads(__tstate);
23095 if (PyErr_Occurred()) SWIG_fail;
23096 }
23097 resultobj = SWIG_From_int(static_cast< int >(result));
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23105 PyObject *resultobj = 0;
23106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23107 bool result;
23108 void *argp1 = 0 ;
23109 int res1 = 0 ;
23110 PyObject *swig_obj[1] ;
23111
23112 if (!args) SWIG_fail;
23113 swig_obj[0] = args;
23114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23115 if (!SWIG_IsOK(res1)) {
23116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23117 }
23118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23135 PyObject *resultobj = 0;
23136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23137 bool result;
23138 void *argp1 = 0 ;
23139 int res1 = 0 ;
23140 PyObject *swig_obj[1] ;
23141
23142 if (!args) SWIG_fail;
23143 swig_obj[0] = args;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23147 }
23148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23157 }
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23165 PyObject *resultobj = 0;
23166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23167 bool result;
23168 void *argp1 = 0 ;
23169 int res1 = 0 ;
23170 PyObject *swig_obj[1] ;
23171
23172 if (!args) SWIG_fail;
23173 swig_obj[0] = args;
23174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23175 if (!SWIG_IsOK(res1)) {
23176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23177 }
23178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23179 {
23180 PyThreadState* __tstate = wxPyBeginAllowThreads();
23181 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23195 PyObject *resultobj = 0;
23196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23197 bool result;
23198 void *argp1 = 0 ;
23199 int res1 = 0 ;
23200 PyObject *swig_obj[1] ;
23201
23202 if (!args) SWIG_fail;
23203 swig_obj[0] = args;
23204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23205 if (!SWIG_IsOK(res1)) {
23206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23207 }
23208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 {
23216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23217 }
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23225 PyObject *resultobj = 0;
23226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23227 bool result;
23228 void *argp1 = 0 ;
23229 int res1 = 0 ;
23230 PyObject *swig_obj[1] ;
23231
23232 if (!args) SWIG_fail;
23233 swig_obj[0] = args;
23234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23237 }
23238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23255 PyObject *resultobj = 0;
23256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23257 bool result;
23258 void *argp1 = 0 ;
23259 int res1 = 0 ;
23260 PyObject *swig_obj[1] ;
23261
23262 if (!args) SWIG_fail;
23263 swig_obj[0] = args;
23264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23265 if (!SWIG_IsOK(res1)) {
23266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23267 }
23268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 {
23276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23277 }
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23285 PyObject *resultobj = 0;
23286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23287 bool result;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 PyObject *swig_obj[1] ;
23291
23292 if (!args) SWIG_fail;
23293 swig_obj[0] = args;
23294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23297 }
23298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *resultobj = 0;
23316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23317 bool result;
23318 void *argp1 = 0 ;
23319 int res1 = 0 ;
23320 PyObject *swig_obj[1] ;
23321
23322 if (!args) SWIG_fail;
23323 swig_obj[0] = args;
23324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23325 if (!SWIG_IsOK(res1)) {
23326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23327 }
23328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 {
23336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23337 }
23338 return resultobj;
23339 fail:
23340 return NULL;
23341 }
23342
23343
23344 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23345 PyObject *resultobj = 0;
23346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23347 bool result;
23348 void *argp1 = 0 ;
23349 int res1 = 0 ;
23350 PyObject *swig_obj[1] ;
23351
23352 if (!args) SWIG_fail;
23353 swig_obj[0] = args;
23354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23355 if (!SWIG_IsOK(res1)) {
23356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23357 }
23358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23362 wxPyEndAllowThreads(__tstate);
23363 if (PyErr_Occurred()) SWIG_fail;
23364 }
23365 {
23366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23367 }
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 PyObject *resultobj = 0;
23376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23377 bool result;
23378 void *argp1 = 0 ;
23379 int res1 = 0 ;
23380 PyObject *swig_obj[1] ;
23381
23382 if (!args) SWIG_fail;
23383 swig_obj[0] = args;
23384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23385 if (!SWIG_IsOK(res1)) {
23386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23387 }
23388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23397 }
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23405 PyObject *resultobj = 0;
23406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23407 bool result;
23408 void *argp1 = 0 ;
23409 int res1 = 0 ;
23410 PyObject *swig_obj[1] ;
23411
23412 if (!args) SWIG_fail;
23413 swig_obj[0] = args;
23414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23415 if (!SWIG_IsOK(res1)) {
23416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23417 }
23418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 {
23426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23427 }
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *resultobj = 0;
23436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23437 bool result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 PyObject *swig_obj[1] ;
23441
23442 if (!args) SWIG_fail;
23443 swig_obj[0] = args;
23444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23445 if (!SWIG_IsOK(res1)) {
23446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23447 }
23448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23452 wxPyEndAllowThreads(__tstate);
23453 if (PyErr_Occurred()) SWIG_fail;
23454 }
23455 {
23456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23457 }
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 PyObject *resultobj = 0;
23466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23467 bool result;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 PyObject *swig_obj[1] ;
23471
23472 if (!args) SWIG_fail;
23473 swig_obj[0] = args;
23474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23475 if (!SWIG_IsOK(res1)) {
23476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23477 }
23478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 {
23486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23487 }
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *resultobj = 0;
23496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23497 bool result;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 PyObject *swig_obj[1] ;
23501
23502 if (!args) SWIG_fail;
23503 swig_obj[0] = args;
23504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23507 }
23508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 PyObject *resultobj = 0;
23526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23527 bool result;
23528 void *argp1 = 0 ;
23529 int res1 = 0 ;
23530 PyObject *swig_obj[1] ;
23531
23532 if (!args) SWIG_fail;
23533 swig_obj[0] = args;
23534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23535 if (!SWIG_IsOK(res1)) {
23536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23537 }
23538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 result = (bool)(arg1)->LeftIsDown();
23542 wxPyEndAllowThreads(__tstate);
23543 if (PyErr_Occurred()) SWIG_fail;
23544 }
23545 {
23546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23547 }
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *resultobj = 0;
23556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23557 bool result;
23558 void *argp1 = 0 ;
23559 int res1 = 0 ;
23560 PyObject *swig_obj[1] ;
23561
23562 if (!args) SWIG_fail;
23563 swig_obj[0] = args;
23564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23565 if (!SWIG_IsOK(res1)) {
23566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23567 }
23568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 result = (bool)(arg1)->MiddleIsDown();
23572 wxPyEndAllowThreads(__tstate);
23573 if (PyErr_Occurred()) SWIG_fail;
23574 }
23575 {
23576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23577 }
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23585 PyObject *resultobj = 0;
23586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23587 bool result;
23588 void *argp1 = 0 ;
23589 int res1 = 0 ;
23590 PyObject *swig_obj[1] ;
23591
23592 if (!args) SWIG_fail;
23593 swig_obj[0] = args;
23594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23595 if (!SWIG_IsOK(res1)) {
23596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23597 }
23598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = (bool)(arg1)->RightIsDown();
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 {
23606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23607 }
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23615 PyObject *resultobj = 0;
23616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23617 bool result;
23618 void *argp1 = 0 ;
23619 int res1 = 0 ;
23620 PyObject *swig_obj[1] ;
23621
23622 if (!args) SWIG_fail;
23623 swig_obj[0] = args;
23624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23625 if (!SWIG_IsOK(res1)) {
23626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23627 }
23628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 {
23636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23637 }
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23645 PyObject *resultobj = 0;
23646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23647 bool result;
23648 void *argp1 = 0 ;
23649 int res1 = 0 ;
23650 PyObject *swig_obj[1] ;
23651
23652 if (!args) SWIG_fail;
23653 swig_obj[0] = args;
23654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23657 }
23658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23662 wxPyEndAllowThreads(__tstate);
23663 if (PyErr_Occurred()) SWIG_fail;
23664 }
23665 {
23666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23667 }
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23675 PyObject *resultobj = 0;
23676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23677 bool result;
23678 void *argp1 = 0 ;
23679 int res1 = 0 ;
23680 PyObject *swig_obj[1] ;
23681
23682 if (!args) SWIG_fail;
23683 swig_obj[0] = args;
23684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23685 if (!SWIG_IsOK(res1)) {
23686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23687 }
23688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 {
23696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23697 }
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23705 PyObject *resultobj = 0;
23706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23707 bool result;
23708 void *argp1 = 0 ;
23709 int res1 = 0 ;
23710 PyObject *swig_obj[1] ;
23711
23712 if (!args) SWIG_fail;
23713 swig_obj[0] = args;
23714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23715 if (!SWIG_IsOK(res1)) {
23716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23717 }
23718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 {
23726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23727 }
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23735 PyObject *resultobj = 0;
23736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23737 wxPoint result;
23738 void *argp1 = 0 ;
23739 int res1 = 0 ;
23740 PyObject *swig_obj[1] ;
23741
23742 if (!args) SWIG_fail;
23743 swig_obj[0] = args;
23744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23747 }
23748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = (arg1)->GetPosition();
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23763 PyObject *resultobj = 0;
23764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23765 long *arg2 = (long *) 0 ;
23766 long *arg3 = (long *) 0 ;
23767 void *argp1 = 0 ;
23768 int res1 = 0 ;
23769 long temp2 ;
23770 int res2 = SWIG_TMPOBJ ;
23771 long temp3 ;
23772 int res3 = SWIG_TMPOBJ ;
23773 PyObject *swig_obj[1] ;
23774
23775 arg2 = &temp2;
23776 arg3 = &temp3;
23777 if (!args) SWIG_fail;
23778 swig_obj[0] = args;
23779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23780 if (!SWIG_IsOK(res1)) {
23781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23782 }
23783 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 (arg1)->GetPosition(arg2,arg3);
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_Py_Void();
23791 if (SWIG_IsTmpObj(res2)) {
23792 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23793 } else {
23794 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23796 }
23797 if (SWIG_IsTmpObj(res3)) {
23798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23799 } else {
23800 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj = 0;
23811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23812 wxDC *arg2 = 0 ;
23813 wxPoint result;
23814 void *argp1 = 0 ;
23815 int res1 = 0 ;
23816 void *argp2 = 0 ;
23817 int res2 = 0 ;
23818 PyObject * obj0 = 0 ;
23819 PyObject * obj1 = 0 ;
23820 char * kwnames[] = {
23821 (char *) "self",(char *) "dc", NULL
23822 };
23823
23824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23826 if (!SWIG_IsOK(res1)) {
23827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23828 }
23829 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23830 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23831 if (!SWIG_IsOK(res2)) {
23832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23833 }
23834 if (!argp2) {
23835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23836 }
23837 arg2 = reinterpret_cast< wxDC * >(argp2);
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *resultobj = 0;
23853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23854 int result;
23855 void *argp1 = 0 ;
23856 int res1 = 0 ;
23857 PyObject *swig_obj[1] ;
23858
23859 if (!args) SWIG_fail;
23860 swig_obj[0] = args;
23861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23862 if (!SWIG_IsOK(res1)) {
23863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23864 }
23865 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (int)((wxMouseEvent const *)arg1)->GetX();
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 resultobj = SWIG_From_int(static_cast< int >(result));
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23880 PyObject *resultobj = 0;
23881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23882 int result;
23883 void *argp1 = 0 ;
23884 int res1 = 0 ;
23885 PyObject *swig_obj[1] ;
23886
23887 if (!args) SWIG_fail;
23888 swig_obj[0] = args;
23889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23890 if (!SWIG_IsOK(res1)) {
23891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23892 }
23893 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23894 {
23895 PyThreadState* __tstate = wxPyBeginAllowThreads();
23896 result = (int)((wxMouseEvent const *)arg1)->GetY();
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 resultobj = SWIG_From_int(static_cast< int >(result));
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23908 PyObject *resultobj = 0;
23909 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23910 int result;
23911 void *argp1 = 0 ;
23912 int res1 = 0 ;
23913 PyObject *swig_obj[1] ;
23914
23915 if (!args) SWIG_fail;
23916 swig_obj[0] = args;
23917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23918 if (!SWIG_IsOK(res1)) {
23919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23920 }
23921 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 resultobj = SWIG_From_int(static_cast< int >(result));
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 PyObject *resultobj = 0;
23937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23938 int result;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 PyObject *swig_obj[1] ;
23942
23943 if (!args) SWIG_fail;
23944 swig_obj[0] = args;
23945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23946 if (!SWIG_IsOK(res1)) {
23947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23948 }
23949 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_From_int(static_cast< int >(result));
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 PyObject *resultobj = 0;
23965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23966 int result;
23967 void *argp1 = 0 ;
23968 int res1 = 0 ;
23969 PyObject *swig_obj[1] ;
23970
23971 if (!args) SWIG_fail;
23972 swig_obj[0] = args;
23973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23974 if (!SWIG_IsOK(res1)) {
23975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23976 }
23977 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 resultobj = SWIG_From_int(static_cast< int >(result));
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23994 bool result;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24004 }
24005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24024 int arg2 ;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 int val2 ;
24028 int ecode2 = 0 ;
24029 PyObject *swig_obj[2] ;
24030
24031 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24033 if (!SWIG_IsOK(res1)) {
24034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24035 }
24036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24038 if (!SWIG_IsOK(ecode2)) {
24039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24040 }
24041 arg2 = static_cast< int >(val2);
24042 if (arg1) (arg1)->m_x = arg2;
24043
24044 resultobj = SWIG_Py_Void();
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24052 PyObject *resultobj = 0;
24053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24054 int result;
24055 void *argp1 = 0 ;
24056 int res1 = 0 ;
24057 PyObject *swig_obj[1] ;
24058
24059 if (!args) SWIG_fail;
24060 swig_obj[0] = args;
24061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24062 if (!SWIG_IsOK(res1)) {
24063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24064 }
24065 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24066 result = (int) ((arg1)->m_x);
24067 resultobj = SWIG_From_int(static_cast< int >(result));
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24077 int arg2 ;
24078 void *argp1 = 0 ;
24079 int res1 = 0 ;
24080 int val2 ;
24081 int ecode2 = 0 ;
24082 PyObject *swig_obj[2] ;
24083
24084 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24086 if (!SWIG_IsOK(res1)) {
24087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24088 }
24089 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24090 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24091 if (!SWIG_IsOK(ecode2)) {
24092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24093 }
24094 arg2 = static_cast< int >(val2);
24095 if (arg1) (arg1)->m_y = arg2;
24096
24097 resultobj = SWIG_Py_Void();
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24105 PyObject *resultobj = 0;
24106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24107 int result;
24108 void *argp1 = 0 ;
24109 int res1 = 0 ;
24110 PyObject *swig_obj[1] ;
24111
24112 if (!args) SWIG_fail;
24113 swig_obj[0] = args;
24114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24115 if (!SWIG_IsOK(res1)) {
24116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24117 }
24118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24119 result = (int) ((arg1)->m_y);
24120 resultobj = SWIG_From_int(static_cast< int >(result));
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128 PyObject *resultobj = 0;
24129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24130 bool arg2 ;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 bool val2 ;
24134 int ecode2 = 0 ;
24135 PyObject *swig_obj[2] ;
24136
24137 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24139 if (!SWIG_IsOK(res1)) {
24140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24141 }
24142 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24143 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24144 if (!SWIG_IsOK(ecode2)) {
24145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24146 }
24147 arg2 = static_cast< bool >(val2);
24148 if (arg1) (arg1)->m_leftDown = arg2;
24149
24150 resultobj = SWIG_Py_Void();
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *resultobj = 0;
24159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24160 bool result;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 PyObject *swig_obj[1] ;
24164
24165 if (!args) SWIG_fail;
24166 swig_obj[0] = args;
24167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24168 if (!SWIG_IsOK(res1)) {
24169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24170 }
24171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24172 result = (bool) ((arg1)->m_leftDown);
24173 {
24174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24175 }
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24183 PyObject *resultobj = 0;
24184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24185 bool arg2 ;
24186 void *argp1 = 0 ;
24187 int res1 = 0 ;
24188 bool val2 ;
24189 int ecode2 = 0 ;
24190 PyObject *swig_obj[2] ;
24191
24192 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24196 }
24197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24198 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24199 if (!SWIG_IsOK(ecode2)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24201 }
24202 arg2 = static_cast< bool >(val2);
24203 if (arg1) (arg1)->m_middleDown = arg2;
24204
24205 resultobj = SWIG_Py_Void();
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24213 PyObject *resultobj = 0;
24214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24215 bool result;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 PyObject *swig_obj[1] ;
24219
24220 if (!args) SWIG_fail;
24221 swig_obj[0] = args;
24222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24225 }
24226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24227 result = (bool) ((arg1)->m_middleDown);
24228 {
24229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24230 }
24231 return resultobj;
24232 fail:
24233 return NULL;
24234 }
24235
24236
24237 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24238 PyObject *resultobj = 0;
24239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24240 bool arg2 ;
24241 void *argp1 = 0 ;
24242 int res1 = 0 ;
24243 bool val2 ;
24244 int ecode2 = 0 ;
24245 PyObject *swig_obj[2] ;
24246
24247 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24249 if (!SWIG_IsOK(res1)) {
24250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24251 }
24252 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24253 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24254 if (!SWIG_IsOK(ecode2)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24256 }
24257 arg2 = static_cast< bool >(val2);
24258 if (arg1) (arg1)->m_rightDown = arg2;
24259
24260 resultobj = SWIG_Py_Void();
24261 return resultobj;
24262 fail:
24263 return NULL;
24264 }
24265
24266
24267 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24268 PyObject *resultobj = 0;
24269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24270 bool result;
24271 void *argp1 = 0 ;
24272 int res1 = 0 ;
24273 PyObject *swig_obj[1] ;
24274
24275 if (!args) SWIG_fail;
24276 swig_obj[0] = args;
24277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24278 if (!SWIG_IsOK(res1)) {
24279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24280 }
24281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24282 result = (bool) ((arg1)->m_rightDown);
24283 {
24284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24285 }
24286 return resultobj;
24287 fail:
24288 return NULL;
24289 }
24290
24291
24292 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24293 PyObject *resultobj = 0;
24294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24295 bool arg2 ;
24296 void *argp1 = 0 ;
24297 int res1 = 0 ;
24298 bool val2 ;
24299 int ecode2 = 0 ;
24300 PyObject *swig_obj[2] ;
24301
24302 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24304 if (!SWIG_IsOK(res1)) {
24305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24306 }
24307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24308 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24309 if (!SWIG_IsOK(ecode2)) {
24310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24311 }
24312 arg2 = static_cast< bool >(val2);
24313 if (arg1) (arg1)->m_controlDown = arg2;
24314
24315 resultobj = SWIG_Py_Void();
24316 return resultobj;
24317 fail:
24318 return NULL;
24319 }
24320
24321
24322 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24323 PyObject *resultobj = 0;
24324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24325 bool result;
24326 void *argp1 = 0 ;
24327 int res1 = 0 ;
24328 PyObject *swig_obj[1] ;
24329
24330 if (!args) SWIG_fail;
24331 swig_obj[0] = args;
24332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24333 if (!SWIG_IsOK(res1)) {
24334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24335 }
24336 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24337 result = (bool) ((arg1)->m_controlDown);
24338 {
24339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24340 }
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24348 PyObject *resultobj = 0;
24349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24350 bool arg2 ;
24351 void *argp1 = 0 ;
24352 int res1 = 0 ;
24353 bool val2 ;
24354 int ecode2 = 0 ;
24355 PyObject *swig_obj[2] ;
24356
24357 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24359 if (!SWIG_IsOK(res1)) {
24360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24361 }
24362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24363 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24364 if (!SWIG_IsOK(ecode2)) {
24365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24366 }
24367 arg2 = static_cast< bool >(val2);
24368 if (arg1) (arg1)->m_shiftDown = arg2;
24369
24370 resultobj = SWIG_Py_Void();
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24378 PyObject *resultobj = 0;
24379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24380 bool result;
24381 void *argp1 = 0 ;
24382 int res1 = 0 ;
24383 PyObject *swig_obj[1] ;
24384
24385 if (!args) SWIG_fail;
24386 swig_obj[0] = args;
24387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24388 if (!SWIG_IsOK(res1)) {
24389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24390 }
24391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24392 result = (bool) ((arg1)->m_shiftDown);
24393 {
24394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24395 }
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 PyObject *resultobj = 0;
24404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24405 bool arg2 ;
24406 void *argp1 = 0 ;
24407 int res1 = 0 ;
24408 bool val2 ;
24409 int ecode2 = 0 ;
24410 PyObject *swig_obj[2] ;
24411
24412 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24416 }
24417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24418 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24419 if (!SWIG_IsOK(ecode2)) {
24420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24421 }
24422 arg2 = static_cast< bool >(val2);
24423 if (arg1) (arg1)->m_altDown = arg2;
24424
24425 resultobj = SWIG_Py_Void();
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *resultobj = 0;
24434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24435 bool result;
24436 void *argp1 = 0 ;
24437 int res1 = 0 ;
24438 PyObject *swig_obj[1] ;
24439
24440 if (!args) SWIG_fail;
24441 swig_obj[0] = args;
24442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24443 if (!SWIG_IsOK(res1)) {
24444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24445 }
24446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24447 result = (bool) ((arg1)->m_altDown);
24448 {
24449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24450 }
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24458 PyObject *resultobj = 0;
24459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24460 bool arg2 ;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 bool val2 ;
24464 int ecode2 = 0 ;
24465 PyObject *swig_obj[2] ;
24466
24467 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24469 if (!SWIG_IsOK(res1)) {
24470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24471 }
24472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24473 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24474 if (!SWIG_IsOK(ecode2)) {
24475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24476 }
24477 arg2 = static_cast< bool >(val2);
24478 if (arg1) (arg1)->m_metaDown = arg2;
24479
24480 resultobj = SWIG_Py_Void();
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24488 PyObject *resultobj = 0;
24489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24490 bool result;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 PyObject *swig_obj[1] ;
24494
24495 if (!args) SWIG_fail;
24496 swig_obj[0] = args;
24497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24498 if (!SWIG_IsOK(res1)) {
24499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24500 }
24501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24502 result = (bool) ((arg1)->m_metaDown);
24503 {
24504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24505 }
24506 return resultobj;
24507 fail:
24508 return NULL;
24509 }
24510
24511
24512 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24513 PyObject *resultobj = 0;
24514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24515 int arg2 ;
24516 void *argp1 = 0 ;
24517 int res1 = 0 ;
24518 int val2 ;
24519 int ecode2 = 0 ;
24520 PyObject *swig_obj[2] ;
24521
24522 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24524 if (!SWIG_IsOK(res1)) {
24525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24526 }
24527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24528 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24529 if (!SWIG_IsOK(ecode2)) {
24530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24531 }
24532 arg2 = static_cast< int >(val2);
24533 if (arg1) (arg1)->m_wheelRotation = arg2;
24534
24535 resultobj = SWIG_Py_Void();
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 PyObject *resultobj = 0;
24544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24545 int result;
24546 void *argp1 = 0 ;
24547 int res1 = 0 ;
24548 PyObject *swig_obj[1] ;
24549
24550 if (!args) SWIG_fail;
24551 swig_obj[0] = args;
24552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24553 if (!SWIG_IsOK(res1)) {
24554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24555 }
24556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24557 result = (int) ((arg1)->m_wheelRotation);
24558 resultobj = SWIG_From_int(static_cast< int >(result));
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24566 PyObject *resultobj = 0;
24567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24568 int arg2 ;
24569 void *argp1 = 0 ;
24570 int res1 = 0 ;
24571 int val2 ;
24572 int ecode2 = 0 ;
24573 PyObject *swig_obj[2] ;
24574
24575 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24579 }
24580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24581 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24584 }
24585 arg2 = static_cast< int >(val2);
24586 if (arg1) (arg1)->m_wheelDelta = arg2;
24587
24588 resultobj = SWIG_Py_Void();
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 PyObject *resultobj = 0;
24597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24598 int result;
24599 void *argp1 = 0 ;
24600 int res1 = 0 ;
24601 PyObject *swig_obj[1] ;
24602
24603 if (!args) SWIG_fail;
24604 swig_obj[0] = args;
24605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24606 if (!SWIG_IsOK(res1)) {
24607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24608 }
24609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24610 result = (int) ((arg1)->m_wheelDelta);
24611 resultobj = SWIG_From_int(static_cast< int >(result));
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24619 PyObject *resultobj = 0;
24620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24621 int arg2 ;
24622 void *argp1 = 0 ;
24623 int res1 = 0 ;
24624 int val2 ;
24625 int ecode2 = 0 ;
24626 PyObject *swig_obj[2] ;
24627
24628 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24630 if (!SWIG_IsOK(res1)) {
24631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24632 }
24633 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24634 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24635 if (!SWIG_IsOK(ecode2)) {
24636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24637 }
24638 arg2 = static_cast< int >(val2);
24639 if (arg1) (arg1)->m_linesPerAction = arg2;
24640
24641 resultobj = SWIG_Py_Void();
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24649 PyObject *resultobj = 0;
24650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24651 int result;
24652 void *argp1 = 0 ;
24653 int res1 = 0 ;
24654 PyObject *swig_obj[1] ;
24655
24656 if (!args) SWIG_fail;
24657 swig_obj[0] = args;
24658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24659 if (!SWIG_IsOK(res1)) {
24660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24661 }
24662 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24663 result = (int) ((arg1)->m_linesPerAction);
24664 resultobj = SWIG_From_int(static_cast< int >(result));
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24672 PyObject *obj;
24673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24675 return SWIG_Py_Void();
24676 }
24677
24678 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24679 return SWIG_Python_InitShadowInstance(args);
24680 }
24681
24682 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24683 PyObject *resultobj = 0;
24684 int arg1 = (int) 0 ;
24685 int arg2 = (int) 0 ;
24686 wxSetCursorEvent *result = 0 ;
24687 int val1 ;
24688 int ecode1 = 0 ;
24689 int val2 ;
24690 int ecode2 = 0 ;
24691 PyObject * obj0 = 0 ;
24692 PyObject * obj1 = 0 ;
24693 char * kwnames[] = {
24694 (char *) "x",(char *) "y", NULL
24695 };
24696
24697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24698 if (obj0) {
24699 ecode1 = SWIG_AsVal_int(obj0, &val1);
24700 if (!SWIG_IsOK(ecode1)) {
24701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24702 }
24703 arg1 = static_cast< int >(val1);
24704 }
24705 if (obj1) {
24706 ecode2 = SWIG_AsVal_int(obj1, &val2);
24707 if (!SWIG_IsOK(ecode2)) {
24708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24709 }
24710 arg2 = static_cast< int >(val2);
24711 }
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *resultobj = 0;
24727 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24728 int result;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 PyObject *swig_obj[1] ;
24732
24733 if (!args) SWIG_fail;
24734 swig_obj[0] = args;
24735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24738 }
24739 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 resultobj = SWIG_From_int(static_cast< int >(result));
24747 return resultobj;
24748 fail:
24749 return NULL;
24750 }
24751
24752
24753 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24754 PyObject *resultobj = 0;
24755 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24756 int result;
24757 void *argp1 = 0 ;
24758 int res1 = 0 ;
24759 PyObject *swig_obj[1] ;
24760
24761 if (!args) SWIG_fail;
24762 swig_obj[0] = args;
24763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24764 if (!SWIG_IsOK(res1)) {
24765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24766 }
24767 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24768 {
24769 PyThreadState* __tstate = wxPyBeginAllowThreads();
24770 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 resultobj = SWIG_From_int(static_cast< int >(result));
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24782 PyObject *resultobj = 0;
24783 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24784 wxCursor *arg2 = 0 ;
24785 void *argp1 = 0 ;
24786 int res1 = 0 ;
24787 void *argp2 = 0 ;
24788 int res2 = 0 ;
24789 PyObject * obj0 = 0 ;
24790 PyObject * obj1 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "self",(char *) "cursor", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24799 }
24800 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24802 if (!SWIG_IsOK(res2)) {
24803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24804 }
24805 if (!argp2) {
24806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24807 }
24808 arg2 = reinterpret_cast< wxCursor * >(argp2);
24809 {
24810 PyThreadState* __tstate = wxPyBeginAllowThreads();
24811 (arg1)->SetCursor((wxCursor const &)*arg2);
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 resultobj = SWIG_Py_Void();
24816 return resultobj;
24817 fail:
24818 return NULL;
24819 }
24820
24821
24822 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24823 PyObject *resultobj = 0;
24824 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24825 wxCursor *result = 0 ;
24826 void *argp1 = 0 ;
24827 int res1 = 0 ;
24828 PyObject *swig_obj[1] ;
24829
24830 if (!args) SWIG_fail;
24831 swig_obj[0] = args;
24832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24833 if (!SWIG_IsOK(res1)) {
24834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24835 }
24836 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24837 {
24838 PyThreadState* __tstate = wxPyBeginAllowThreads();
24839 {
24840 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24841 result = (wxCursor *) &_result_ref;
24842 }
24843 wxPyEndAllowThreads(__tstate);
24844 if (PyErr_Occurred()) SWIG_fail;
24845 }
24846 {
24847 wxCursor* resultptr = new wxCursor(*result);
24848 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24849 }
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24857 PyObject *resultobj = 0;
24858 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24859 bool result;
24860 void *argp1 = 0 ;
24861 int res1 = 0 ;
24862 PyObject *swig_obj[1] ;
24863
24864 if (!args) SWIG_fail;
24865 swig_obj[0] = args;
24866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24867 if (!SWIG_IsOK(res1)) {
24868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24869 }
24870 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24871 {
24872 PyThreadState* __tstate = wxPyBeginAllowThreads();
24873 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24879 }
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24887 PyObject *obj;
24888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24889 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24890 return SWIG_Py_Void();
24891 }
24892
24893 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24894 return SWIG_Python_InitShadowInstance(args);
24895 }
24896
24897 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24898 PyObject *resultobj = 0;
24899 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24900 wxKeyEvent *result = 0 ;
24901 int val1 ;
24902 int ecode1 = 0 ;
24903 PyObject * obj0 = 0 ;
24904 char * kwnames[] = {
24905 (char *) "eventType", NULL
24906 };
24907
24908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24909 if (obj0) {
24910 ecode1 = SWIG_AsVal_int(obj0, &val1);
24911 if (!SWIG_IsOK(ecode1)) {
24912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24913 }
24914 arg1 = static_cast< wxEventType >(val1);
24915 }
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24930 PyObject *resultobj = 0;
24931 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24932 int result;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 PyObject *swig_obj[1] ;
24936
24937 if (!args) SWIG_fail;
24938 swig_obj[0] = args;
24939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24940 if (!SWIG_IsOK(res1)) {
24941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24942 }
24943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24944 {
24945 PyThreadState* __tstate = wxPyBeginAllowThreads();
24946 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 resultobj = SWIG_From_int(static_cast< int >(result));
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24958 PyObject *resultobj = 0;
24959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24960 bool result;
24961 void *argp1 = 0 ;
24962 int res1 = 0 ;
24963 PyObject *swig_obj[1] ;
24964
24965 if (!args) SWIG_fail;
24966 swig_obj[0] = args;
24967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24968 if (!SWIG_IsOK(res1)) {
24969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24970 }
24971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24990 bool result;
24991 void *argp1 = 0 ;
24992 int res1 = 0 ;
24993 PyObject *swig_obj[1] ;
24994
24995 if (!args) SWIG_fail;
24996 swig_obj[0] = args;
24997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25000 }
25001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 {
25009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25010 }
25011 return resultobj;
25012 fail:
25013 return NULL;
25014 }
25015
25016
25017 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25018 PyObject *resultobj = 0;
25019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25020 bool result;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 PyObject *swig_obj[1] ;
25024
25025 if (!args) SWIG_fail;
25026 swig_obj[0] = args;
25027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25028 if (!SWIG_IsOK(res1)) {
25029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25030 }
25031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 {
25039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25040 }
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25048 PyObject *resultobj = 0;
25049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25050 bool result;
25051 void *argp1 = 0 ;
25052 int res1 = 0 ;
25053 PyObject *swig_obj[1] ;
25054
25055 if (!args) SWIG_fail;
25056 swig_obj[0] = args;
25057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25058 if (!SWIG_IsOK(res1)) {
25059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25060 }
25061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25078 PyObject *resultobj = 0;
25079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25080 bool result;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 PyObject *swig_obj[1] ;
25084
25085 if (!args) SWIG_fail;
25086 swig_obj[0] = args;
25087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25088 if (!SWIG_IsOK(res1)) {
25089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25090 }
25091 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25095 wxPyEndAllowThreads(__tstate);
25096 if (PyErr_Occurred()) SWIG_fail;
25097 }
25098 {
25099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25100 }
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25108 PyObject *resultobj = 0;
25109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25110 bool result;
25111 void *argp1 = 0 ;
25112 int res1 = 0 ;
25113 PyObject *swig_obj[1] ;
25114
25115 if (!args) SWIG_fail;
25116 swig_obj[0] = args;
25117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25118 if (!SWIG_IsOK(res1)) {
25119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25120 }
25121 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 {
25129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25130 }
25131 return resultobj;
25132 fail:
25133 return NULL;
25134 }
25135
25136
25137 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25138 PyObject *resultobj = 0;
25139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25140 int result;
25141 void *argp1 = 0 ;
25142 int res1 = 0 ;
25143 PyObject *swig_obj[1] ;
25144
25145 if (!args) SWIG_fail;
25146 swig_obj[0] = args;
25147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25148 if (!SWIG_IsOK(res1)) {
25149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25150 }
25151 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 resultobj = SWIG_From_int(static_cast< int >(result));
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25166 PyObject *resultobj = 0;
25167 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25168 int result;
25169 void *argp1 = 0 ;
25170 int res1 = 0 ;
25171 PyObject *swig_obj[1] ;
25172
25173 if (!args) SWIG_fail;
25174 swig_obj[0] = args;
25175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25176 if (!SWIG_IsOK(res1)) {
25177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25178 }
25179 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_From_int(static_cast< int >(result));
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj = 0;
25195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25196 int arg2 ;
25197 void *argp1 = 0 ;
25198 int res1 = 0 ;
25199 int val2 ;
25200 int ecode2 = 0 ;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 char * kwnames[] = {
25204 (char *) "self",(char *) "uniChar", NULL
25205 };
25206
25207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25209 if (!SWIG_IsOK(res1)) {
25210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25211 }
25212 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25213 ecode2 = SWIG_AsVal_int(obj1, &val2);
25214 if (!SWIG_IsOK(ecode2)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25216 }
25217 arg2 = static_cast< int >(val2);
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 resultobj = SWIG_Py_Void();
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 PyObject *resultobj = 0;
25233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25234 unsigned int result;
25235 void *argp1 = 0 ;
25236 int res1 = 0 ;
25237 PyObject *swig_obj[1] ;
25238
25239 if (!args) SWIG_fail;
25240 swig_obj[0] = args;
25241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25242 if (!SWIG_IsOK(res1)) {
25243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25244 }
25245 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25246 {
25247 PyThreadState* __tstate = wxPyBeginAllowThreads();
25248 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25249 wxPyEndAllowThreads(__tstate);
25250 if (PyErr_Occurred()) SWIG_fail;
25251 }
25252 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25260 PyObject *resultobj = 0;
25261 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25262 unsigned int result;
25263 void *argp1 = 0 ;
25264 int res1 = 0 ;
25265 PyObject *swig_obj[1] ;
25266
25267 if (!args) SWIG_fail;
25268 swig_obj[0] = args;
25269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25270 if (!SWIG_IsOK(res1)) {
25271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25272 }
25273 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25274 {
25275 PyThreadState* __tstate = wxPyBeginAllowThreads();
25276 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25288 PyObject *resultobj = 0;
25289 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25290 wxPoint result;
25291 void *argp1 = 0 ;
25292 int res1 = 0 ;
25293 PyObject *swig_obj[1] ;
25294
25295 if (!args) SWIG_fail;
25296 swig_obj[0] = args;
25297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25298 if (!SWIG_IsOK(res1)) {
25299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25300 }
25301 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = (arg1)->GetPosition();
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25316 PyObject *resultobj = 0;
25317 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25318 long *arg2 = (long *) 0 ;
25319 long *arg3 = (long *) 0 ;
25320 void *argp1 = 0 ;
25321 int res1 = 0 ;
25322 long temp2 ;
25323 int res2 = SWIG_TMPOBJ ;
25324 long temp3 ;
25325 int res3 = SWIG_TMPOBJ ;
25326 PyObject *swig_obj[1] ;
25327
25328 arg2 = &temp2;
25329 arg3 = &temp3;
25330 if (!args) SWIG_fail;
25331 swig_obj[0] = args;
25332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25335 }
25336 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 (arg1)->GetPosition(arg2,arg3);
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_Py_Void();
25344 if (SWIG_IsTmpObj(res2)) {
25345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25346 } else {
25347 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25349 }
25350 if (SWIG_IsTmpObj(res3)) {
25351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25352 } else {
25353 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25355 }
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25363 PyObject *resultobj = 0;
25364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25365 int result;
25366 void *argp1 = 0 ;
25367 int res1 = 0 ;
25368 PyObject *swig_obj[1] ;
25369
25370 if (!args) SWIG_fail;
25371 swig_obj[0] = args;
25372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25373 if (!SWIG_IsOK(res1)) {
25374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25375 }
25376 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (int)((wxKeyEvent const *)arg1)->GetX();
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 resultobj = SWIG_From_int(static_cast< int >(result));
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25391 PyObject *resultobj = 0;
25392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25393 int result;
25394 void *argp1 = 0 ;
25395 int res1 = 0 ;
25396 PyObject *swig_obj[1] ;
25397
25398 if (!args) SWIG_fail;
25399 swig_obj[0] = args;
25400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25401 if (!SWIG_IsOK(res1)) {
25402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25403 }
25404 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 result = (int)((wxKeyEvent const *)arg1)->GetY();
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 resultobj = SWIG_From_int(static_cast< int >(result));
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25421 int arg2 ;
25422 void *argp1 = 0 ;
25423 int res1 = 0 ;
25424 int val2 ;
25425 int ecode2 = 0 ;
25426 PyObject *swig_obj[2] ;
25427
25428 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25430 if (!SWIG_IsOK(res1)) {
25431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25432 }
25433 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25434 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25435 if (!SWIG_IsOK(ecode2)) {
25436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25437 }
25438 arg2 = static_cast< int >(val2);
25439 if (arg1) (arg1)->m_x = arg2;
25440
25441 resultobj = SWIG_Py_Void();
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25449 PyObject *resultobj = 0;
25450 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25451 int result;
25452 void *argp1 = 0 ;
25453 int res1 = 0 ;
25454 PyObject *swig_obj[1] ;
25455
25456 if (!args) SWIG_fail;
25457 swig_obj[0] = args;
25458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25459 if (!SWIG_IsOK(res1)) {
25460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25461 }
25462 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25463 result = (int) ((arg1)->m_x);
25464 resultobj = SWIG_From_int(static_cast< int >(result));
25465 return resultobj;
25466 fail:
25467 return NULL;
25468 }
25469
25470
25471 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 PyObject *resultobj = 0;
25473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25474 int arg2 ;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 int val2 ;
25478 int ecode2 = 0 ;
25479 PyObject *swig_obj[2] ;
25480
25481 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25483 if (!SWIG_IsOK(res1)) {
25484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25485 }
25486 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25487 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25488 if (!SWIG_IsOK(ecode2)) {
25489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25490 }
25491 arg2 = static_cast< int >(val2);
25492 if (arg1) (arg1)->m_y = arg2;
25493
25494 resultobj = SWIG_Py_Void();
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25502 PyObject *resultobj = 0;
25503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25504 int result;
25505 void *argp1 = 0 ;
25506 int res1 = 0 ;
25507 PyObject *swig_obj[1] ;
25508
25509 if (!args) SWIG_fail;
25510 swig_obj[0] = args;
25511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25512 if (!SWIG_IsOK(res1)) {
25513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25514 }
25515 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25516 result = (int) ((arg1)->m_y);
25517 resultobj = SWIG_From_int(static_cast< int >(result));
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 PyObject *resultobj = 0;
25526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25527 long arg2 ;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 long val2 ;
25531 int ecode2 = 0 ;
25532 PyObject *swig_obj[2] ;
25533
25534 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25538 }
25539 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25540 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25541 if (!SWIG_IsOK(ecode2)) {
25542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25543 }
25544 arg2 = static_cast< long >(val2);
25545 if (arg1) (arg1)->m_keyCode = arg2;
25546
25547 resultobj = SWIG_Py_Void();
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 PyObject *resultobj = 0;
25556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25557 long result;
25558 void *argp1 = 0 ;
25559 int res1 = 0 ;
25560 PyObject *swig_obj[1] ;
25561
25562 if (!args) SWIG_fail;
25563 swig_obj[0] = args;
25564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25565 if (!SWIG_IsOK(res1)) {
25566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25567 }
25568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25569 result = (long) ((arg1)->m_keyCode);
25570 resultobj = SWIG_From_long(static_cast< long >(result));
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25578 PyObject *resultobj = 0;
25579 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25580 bool arg2 ;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 bool val2 ;
25584 int ecode2 = 0 ;
25585 PyObject *swig_obj[2] ;
25586
25587 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25589 if (!SWIG_IsOK(res1)) {
25590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25591 }
25592 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25593 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25594 if (!SWIG_IsOK(ecode2)) {
25595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25596 }
25597 arg2 = static_cast< bool >(val2);
25598 if (arg1) (arg1)->m_controlDown = arg2;
25599
25600 resultobj = SWIG_Py_Void();
25601 return resultobj;
25602 fail:
25603 return NULL;
25604 }
25605
25606
25607 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25608 PyObject *resultobj = 0;
25609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25610 bool result;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 PyObject *swig_obj[1] ;
25614
25615 if (!args) SWIG_fail;
25616 swig_obj[0] = args;
25617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25618 if (!SWIG_IsOK(res1)) {
25619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25620 }
25621 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25622 result = (bool) ((arg1)->m_controlDown);
25623 {
25624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25625 }
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25633 PyObject *resultobj = 0;
25634 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25635 bool arg2 ;
25636 void *argp1 = 0 ;
25637 int res1 = 0 ;
25638 bool val2 ;
25639 int ecode2 = 0 ;
25640 PyObject *swig_obj[2] ;
25641
25642 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25644 if (!SWIG_IsOK(res1)) {
25645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25646 }
25647 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25648 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25649 if (!SWIG_IsOK(ecode2)) {
25650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25651 }
25652 arg2 = static_cast< bool >(val2);
25653 if (arg1) (arg1)->m_shiftDown = arg2;
25654
25655 resultobj = SWIG_Py_Void();
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25663 PyObject *resultobj = 0;
25664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25665 bool result;
25666 void *argp1 = 0 ;
25667 int res1 = 0 ;
25668 PyObject *swig_obj[1] ;
25669
25670 if (!args) SWIG_fail;
25671 swig_obj[0] = args;
25672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25673 if (!SWIG_IsOK(res1)) {
25674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25675 }
25676 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25677 result = (bool) ((arg1)->m_shiftDown);
25678 {
25679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25688 PyObject *resultobj = 0;
25689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25690 bool arg2 ;
25691 void *argp1 = 0 ;
25692 int res1 = 0 ;
25693 bool val2 ;
25694 int ecode2 = 0 ;
25695 PyObject *swig_obj[2] ;
25696
25697 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25699 if (!SWIG_IsOK(res1)) {
25700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25701 }
25702 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25703 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25704 if (!SWIG_IsOK(ecode2)) {
25705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25706 }
25707 arg2 = static_cast< bool >(val2);
25708 if (arg1) (arg1)->m_altDown = arg2;
25709
25710 resultobj = SWIG_Py_Void();
25711 return resultobj;
25712 fail:
25713 return NULL;
25714 }
25715
25716
25717 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25718 PyObject *resultobj = 0;
25719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25720 bool result;
25721 void *argp1 = 0 ;
25722 int res1 = 0 ;
25723 PyObject *swig_obj[1] ;
25724
25725 if (!args) SWIG_fail;
25726 swig_obj[0] = args;
25727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25728 if (!SWIG_IsOK(res1)) {
25729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25730 }
25731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25732 result = (bool) ((arg1)->m_altDown);
25733 {
25734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25735 }
25736 return resultobj;
25737 fail:
25738 return NULL;
25739 }
25740
25741
25742 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25743 PyObject *resultobj = 0;
25744 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25745 bool arg2 ;
25746 void *argp1 = 0 ;
25747 int res1 = 0 ;
25748 bool val2 ;
25749 int ecode2 = 0 ;
25750 PyObject *swig_obj[2] ;
25751
25752 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25754 if (!SWIG_IsOK(res1)) {
25755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25756 }
25757 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25758 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25759 if (!SWIG_IsOK(ecode2)) {
25760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25761 }
25762 arg2 = static_cast< bool >(val2);
25763 if (arg1) (arg1)->m_metaDown = arg2;
25764
25765 resultobj = SWIG_Py_Void();
25766 return resultobj;
25767 fail:
25768 return NULL;
25769 }
25770
25771
25772 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25773 PyObject *resultobj = 0;
25774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25775 bool result;
25776 void *argp1 = 0 ;
25777 int res1 = 0 ;
25778 PyObject *swig_obj[1] ;
25779
25780 if (!args) SWIG_fail;
25781 swig_obj[0] = args;
25782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25783 if (!SWIG_IsOK(res1)) {
25784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25785 }
25786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25787 result = (bool) ((arg1)->m_metaDown);
25788 {
25789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25790 }
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *resultobj = 0;
25799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25800 bool arg2 ;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 bool val2 ;
25804 int ecode2 = 0 ;
25805 PyObject *swig_obj[2] ;
25806
25807 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25809 if (!SWIG_IsOK(res1)) {
25810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25811 }
25812 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25813 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25814 if (!SWIG_IsOK(ecode2)) {
25815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25816 }
25817 arg2 = static_cast< bool >(val2);
25818 if (arg1) (arg1)->m_scanCode = arg2;
25819
25820 resultobj = SWIG_Py_Void();
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25828 PyObject *resultobj = 0;
25829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25830 bool result;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 PyObject *swig_obj[1] ;
25834
25835 if (!args) SWIG_fail;
25836 swig_obj[0] = args;
25837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25838 if (!SWIG_IsOK(res1)) {
25839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25840 }
25841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25842 result = (bool) ((arg1)->m_scanCode);
25843 {
25844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25845 }
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 PyObject *resultobj = 0;
25854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25855 unsigned int arg2 ;
25856 void *argp1 = 0 ;
25857 int res1 = 0 ;
25858 unsigned int val2 ;
25859 int ecode2 = 0 ;
25860 PyObject *swig_obj[2] ;
25861
25862 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25864 if (!SWIG_IsOK(res1)) {
25865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25866 }
25867 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25868 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25869 if (!SWIG_IsOK(ecode2)) {
25870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25871 }
25872 arg2 = static_cast< unsigned int >(val2);
25873 if (arg1) (arg1)->m_rawCode = arg2;
25874
25875 resultobj = SWIG_Py_Void();
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25883 PyObject *resultobj = 0;
25884 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25885 unsigned int result;
25886 void *argp1 = 0 ;
25887 int res1 = 0 ;
25888 PyObject *swig_obj[1] ;
25889
25890 if (!args) SWIG_fail;
25891 swig_obj[0] = args;
25892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25893 if (!SWIG_IsOK(res1)) {
25894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25895 }
25896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25897 result = (unsigned int) ((arg1)->m_rawCode);
25898 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25906 PyObject *resultobj = 0;
25907 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25908 unsigned int arg2 ;
25909 void *argp1 = 0 ;
25910 int res1 = 0 ;
25911 unsigned int val2 ;
25912 int ecode2 = 0 ;
25913 PyObject *swig_obj[2] ;
25914
25915 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25917 if (!SWIG_IsOK(res1)) {
25918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25919 }
25920 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25921 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25922 if (!SWIG_IsOK(ecode2)) {
25923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25924 }
25925 arg2 = static_cast< unsigned int >(val2);
25926 if (arg1) (arg1)->m_rawFlags = arg2;
25927
25928 resultobj = SWIG_Py_Void();
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936 PyObject *resultobj = 0;
25937 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25938 unsigned int result;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 PyObject *swig_obj[1] ;
25942
25943 if (!args) SWIG_fail;
25944 swig_obj[0] = args;
25945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25948 }
25949 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25950 result = (unsigned int) ((arg1)->m_rawFlags);
25951 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25959 PyObject *obj;
25960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25961 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25962 return SWIG_Py_Void();
25963 }
25964
25965 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25966 return SWIG_Python_InitShadowInstance(args);
25967 }
25968
25969 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25970 PyObject *resultobj = 0;
25971 wxSize const &arg1_defvalue = wxDefaultSize ;
25972 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25973 int arg2 = (int) 0 ;
25974 wxSizeEvent *result = 0 ;
25975 wxSize temp1 ;
25976 int val2 ;
25977 int ecode2 = 0 ;
25978 PyObject * obj0 = 0 ;
25979 PyObject * obj1 = 0 ;
25980 char * kwnames[] = {
25981 (char *) "sz",(char *) "winid", NULL
25982 };
25983
25984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25985 if (obj0) {
25986 {
25987 arg1 = &temp1;
25988 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25989 }
25990 }
25991 if (obj1) {
25992 ecode2 = SWIG_AsVal_int(obj1, &val2);
25993 if (!SWIG_IsOK(ecode2)) {
25994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25995 }
25996 arg2 = static_cast< int >(val2);
25997 }
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26012 PyObject *resultobj = 0;
26013 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26014 wxSize result;
26015 void *argp1 = 0 ;
26016 int res1 = 0 ;
26017 PyObject *swig_obj[1] ;
26018
26019 if (!args) SWIG_fail;
26020 swig_obj[0] = args;
26021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26022 if (!SWIG_IsOK(res1)) {
26023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26024 }
26025 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 result = ((wxSizeEvent const *)arg1)->GetSize();
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26040 PyObject *resultobj = 0;
26041 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26042 wxRect result;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 PyObject *swig_obj[1] ;
26046
26047 if (!args) SWIG_fail;
26048 swig_obj[0] = args;
26049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26050 if (!SWIG_IsOK(res1)) {
26051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26052 }
26053 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26054 {
26055 PyThreadState* __tstate = wxPyBeginAllowThreads();
26056 result = ((wxSizeEvent const *)arg1)->GetRect();
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj = 0;
26069 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26070 wxRect arg2 ;
26071 void *argp1 = 0 ;
26072 int res1 = 0 ;
26073 void *argp2 ;
26074 int res2 = 0 ;
26075 PyObject * obj0 = 0 ;
26076 PyObject * obj1 = 0 ;
26077 char * kwnames[] = {
26078 (char *) "self",(char *) "rect", NULL
26079 };
26080
26081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26083 if (!SWIG_IsOK(res1)) {
26084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26085 }
26086 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26087 {
26088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26089 if (!SWIG_IsOK(res2)) {
26090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26091 }
26092 if (!argp2) {
26093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26094 } else {
26095 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26096 arg2 = *temp;
26097 if (SWIG_IsNewObj(res2)) delete temp;
26098 }
26099 }
26100 {
26101 PyThreadState* __tstate = wxPyBeginAllowThreads();
26102 (arg1)->SetRect(arg2);
26103 wxPyEndAllowThreads(__tstate);
26104 if (PyErr_Occurred()) SWIG_fail;
26105 }
26106 resultobj = SWIG_Py_Void();
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj = 0;
26115 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26116 wxSize arg2 ;
26117 void *argp1 = 0 ;
26118 int res1 = 0 ;
26119 void *argp2 ;
26120 int res2 = 0 ;
26121 PyObject * obj0 = 0 ;
26122 PyObject * obj1 = 0 ;
26123 char * kwnames[] = {
26124 (char *) "self",(char *) "size", NULL
26125 };
26126
26127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26129 if (!SWIG_IsOK(res1)) {
26130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26131 }
26132 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26133 {
26134 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26135 if (!SWIG_IsOK(res2)) {
26136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26137 }
26138 if (!argp2) {
26139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26140 } else {
26141 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26142 arg2 = *temp;
26143 if (SWIG_IsNewObj(res2)) delete temp;
26144 }
26145 }
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 wxSizeEvent_SetSize(arg1,arg2);
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 resultobj = SWIG_Py_Void();
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26160 PyObject *resultobj = 0;
26161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26162 wxSize *arg2 = (wxSize *) 0 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 void *argp2 = 0 ;
26166 int res2 = 0 ;
26167 PyObject *swig_obj[2] ;
26168
26169 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26173 }
26174 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26175 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26176 if (!SWIG_IsOK(res2)) {
26177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26178 }
26179 arg2 = reinterpret_cast< wxSize * >(argp2);
26180 if (arg1) (arg1)->m_size = *arg2;
26181
26182 resultobj = SWIG_Py_Void();
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 PyObject *resultobj = 0;
26191 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26192 wxSize *result = 0 ;
26193 void *argp1 = 0 ;
26194 int res1 = 0 ;
26195 PyObject *swig_obj[1] ;
26196
26197 if (!args) SWIG_fail;
26198 swig_obj[0] = args;
26199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26200 if (!SWIG_IsOK(res1)) {
26201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26202 }
26203 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26204 result = (wxSize *)& ((arg1)->m_size);
26205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26213 PyObject *resultobj = 0;
26214 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26215 wxRect *arg2 = (wxRect *) 0 ;
26216 void *argp1 = 0 ;
26217 int res1 = 0 ;
26218 void *argp2 = 0 ;
26219 int res2 = 0 ;
26220 PyObject *swig_obj[2] ;
26221
26222 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26224 if (!SWIG_IsOK(res1)) {
26225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26226 }
26227 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26228 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26229 if (!SWIG_IsOK(res2)) {
26230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26231 }
26232 arg2 = reinterpret_cast< wxRect * >(argp2);
26233 if (arg1) (arg1)->m_rect = *arg2;
26234
26235 resultobj = SWIG_Py_Void();
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *resultobj = 0;
26244 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26245 wxRect *result = 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject *swig_obj[1] ;
26249
26250 if (!args) SWIG_fail;
26251 swig_obj[0] = args;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26255 }
26256 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26257 result = (wxRect *)& ((arg1)->m_rect);
26258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26266 PyObject *obj;
26267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26268 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26269 return SWIG_Py_Void();
26270 }
26271
26272 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26273 return SWIG_Python_InitShadowInstance(args);
26274 }
26275
26276 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj = 0;
26278 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26279 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26280 int arg2 = (int) 0 ;
26281 wxMoveEvent *result = 0 ;
26282 wxPoint temp1 ;
26283 int val2 ;
26284 int ecode2 = 0 ;
26285 PyObject * obj0 = 0 ;
26286 PyObject * obj1 = 0 ;
26287 char * kwnames[] = {
26288 (char *) "pos",(char *) "winid", NULL
26289 };
26290
26291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26292 if (obj0) {
26293 {
26294 arg1 = &temp1;
26295 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26296 }
26297 }
26298 if (obj1) {
26299 ecode2 = SWIG_AsVal_int(obj1, &val2);
26300 if (!SWIG_IsOK(ecode2)) {
26301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26302 }
26303 arg2 = static_cast< int >(val2);
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 PyObject *resultobj = 0;
26320 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26321 wxPoint result;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 PyObject *swig_obj[1] ;
26325
26326 if (!args) SWIG_fail;
26327 swig_obj[0] = args;
26328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26331 }
26332 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 result = ((wxMoveEvent const *)arg1)->GetPosition();
26336 wxPyEndAllowThreads(__tstate);
26337 if (PyErr_Occurred()) SWIG_fail;
26338 }
26339 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26347 PyObject *resultobj = 0;
26348 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26349 wxRect result;
26350 void *argp1 = 0 ;
26351 int res1 = 0 ;
26352 PyObject *swig_obj[1] ;
26353
26354 if (!args) SWIG_fail;
26355 swig_obj[0] = args;
26356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26359 }
26360 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = ((wxMoveEvent const *)arg1)->GetRect();
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26368 return resultobj;
26369 fail:
26370 return NULL;
26371 }
26372
26373
26374 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26375 PyObject *resultobj = 0;
26376 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26377 wxRect *arg2 = 0 ;
26378 void *argp1 = 0 ;
26379 int res1 = 0 ;
26380 wxRect temp2 ;
26381 PyObject * obj0 = 0 ;
26382 PyObject * obj1 = 0 ;
26383 char * kwnames[] = {
26384 (char *) "self",(char *) "rect", NULL
26385 };
26386
26387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26391 }
26392 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26393 {
26394 arg2 = &temp2;
26395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26396 }
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 (arg1)->SetRect((wxRect const &)*arg2);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 resultobj = SWIG_Py_Void();
26404 return resultobj;
26405 fail:
26406 return NULL;
26407 }
26408
26409
26410 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26411 PyObject *resultobj = 0;
26412 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26413 wxPoint *arg2 = 0 ;
26414 void *argp1 = 0 ;
26415 int res1 = 0 ;
26416 wxPoint temp2 ;
26417 PyObject * obj0 = 0 ;
26418 PyObject * obj1 = 0 ;
26419 char * kwnames[] = {
26420 (char *) "self",(char *) "pos", NULL
26421 };
26422
26423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26425 if (!SWIG_IsOK(res1)) {
26426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26427 }
26428 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26429 {
26430 arg2 = &temp2;
26431 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26432 }
26433 {
26434 PyThreadState* __tstate = wxPyBeginAllowThreads();
26435 (arg1)->SetPosition((wxPoint const &)*arg2);
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 resultobj = SWIG_Py_Void();
26440 return resultobj;
26441 fail:
26442 return NULL;
26443 }
26444
26445
26446 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26447 PyObject *obj;
26448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26449 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26450 return SWIG_Py_Void();
26451 }
26452
26453 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26454 return SWIG_Python_InitShadowInstance(args);
26455 }
26456
26457 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj = 0;
26459 int arg1 = (int) 0 ;
26460 wxPaintEvent *result = 0 ;
26461 int val1 ;
26462 int ecode1 = 0 ;
26463 PyObject * obj0 = 0 ;
26464 char * kwnames[] = {
26465 (char *) "Id", NULL
26466 };
26467
26468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26469 if (obj0) {
26470 ecode1 = SWIG_AsVal_int(obj0, &val1);
26471 if (!SWIG_IsOK(ecode1)) {
26472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26473 }
26474 arg1 = static_cast< int >(val1);
26475 }
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26490 PyObject *obj;
26491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26492 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26493 return SWIG_Py_Void();
26494 }
26495
26496 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26497 return SWIG_Python_InitShadowInstance(args);
26498 }
26499
26500 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 int arg1 = (int) 0 ;
26503 wxNcPaintEvent *result = 0 ;
26504 int val1 ;
26505 int ecode1 = 0 ;
26506 PyObject * obj0 = 0 ;
26507 char * kwnames[] = {
26508 (char *) "winid", NULL
26509 };
26510
26511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26512 if (obj0) {
26513 ecode1 = SWIG_AsVal_int(obj0, &val1);
26514 if (!SWIG_IsOK(ecode1)) {
26515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26516 }
26517 arg1 = static_cast< int >(val1);
26518 }
26519 {
26520 PyThreadState* __tstate = wxPyBeginAllowThreads();
26521 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 PyObject *obj;
26534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26535 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26536 return SWIG_Py_Void();
26537 }
26538
26539 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26540 return SWIG_Python_InitShadowInstance(args);
26541 }
26542
26543 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26544 PyObject *resultobj = 0;
26545 int arg1 = (int) 0 ;
26546 wxDC *arg2 = (wxDC *) NULL ;
26547 wxEraseEvent *result = 0 ;
26548 int val1 ;
26549 int ecode1 = 0 ;
26550 void *argp2 = 0 ;
26551 int res2 = 0 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char * kwnames[] = {
26555 (char *) "Id",(char *) "dc", NULL
26556 };
26557
26558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26559 if (obj0) {
26560 ecode1 = SWIG_AsVal_int(obj0, &val1);
26561 if (!SWIG_IsOK(ecode1)) {
26562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26563 }
26564 arg1 = static_cast< int >(val1);
26565 }
26566 if (obj1) {
26567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26568 if (!SWIG_IsOK(res2)) {
26569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26570 }
26571 arg2 = reinterpret_cast< wxDC * >(argp2);
26572 }
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26580 return resultobj;
26581 fail:
26582 return NULL;
26583 }
26584
26585
26586 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26587 PyObject *resultobj = 0;
26588 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26589 wxDC *result = 0 ;
26590 void *argp1 = 0 ;
26591 int res1 = 0 ;
26592 PyObject *swig_obj[1] ;
26593
26594 if (!args) SWIG_fail;
26595 swig_obj[0] = args;
26596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26597 if (!SWIG_IsOK(res1)) {
26598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26599 }
26600 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26601 {
26602 PyThreadState* __tstate = wxPyBeginAllowThreads();
26603 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 {
26608 resultobj = wxPyMake_wxObject(result, (bool)0);
26609 }
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26617 PyObject *obj;
26618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26619 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26620 return SWIG_Py_Void();
26621 }
26622
26623 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26624 return SWIG_Python_InitShadowInstance(args);
26625 }
26626
26627 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj = 0;
26629 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26630 int arg2 = (int) 0 ;
26631 wxFocusEvent *result = 0 ;
26632 int val1 ;
26633 int ecode1 = 0 ;
26634 int val2 ;
26635 int ecode2 = 0 ;
26636 PyObject * obj0 = 0 ;
26637 PyObject * obj1 = 0 ;
26638 char * kwnames[] = {
26639 (char *) "type",(char *) "winid", NULL
26640 };
26641
26642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26643 if (obj0) {
26644 ecode1 = SWIG_AsVal_int(obj0, &val1);
26645 if (!SWIG_IsOK(ecode1)) {
26646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26647 }
26648 arg1 = static_cast< wxEventType >(val1);
26649 }
26650 if (obj1) {
26651 ecode2 = SWIG_AsVal_int(obj1, &val2);
26652 if (!SWIG_IsOK(ecode2)) {
26653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26654 }
26655 arg2 = static_cast< int >(val2);
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 PyObject *resultobj = 0;
26672 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26673 wxWindow *result = 0 ;
26674 void *argp1 = 0 ;
26675 int res1 = 0 ;
26676 PyObject *swig_obj[1] ;
26677
26678 if (!args) SWIG_fail;
26679 swig_obj[0] = args;
26680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26683 }
26684 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 {
26692 resultobj = wxPyMake_wxObject(result, (bool)0);
26693 }
26694 return resultobj;
26695 fail:
26696 return NULL;
26697 }
26698
26699
26700 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26701 PyObject *resultobj = 0;
26702 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26703 wxWindow *arg2 = (wxWindow *) 0 ;
26704 void *argp1 = 0 ;
26705 int res1 = 0 ;
26706 void *argp2 = 0 ;
26707 int res2 = 0 ;
26708 PyObject * obj0 = 0 ;
26709 PyObject * obj1 = 0 ;
26710 char * kwnames[] = {
26711 (char *) "self",(char *) "win", NULL
26712 };
26713
26714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26718 }
26719 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26721 if (!SWIG_IsOK(res2)) {
26722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26723 }
26724 arg2 = reinterpret_cast< wxWindow * >(argp2);
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 (arg1)->SetWindow(arg2);
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 resultobj = SWIG_Py_Void();
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26739 PyObject *obj;
26740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26741 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26742 return SWIG_Py_Void();
26743 }
26744
26745 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26746 return SWIG_Python_InitShadowInstance(args);
26747 }
26748
26749 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxWindow *arg1 = (wxWindow *) NULL ;
26752 wxChildFocusEvent *result = 0 ;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 char * kwnames[] = {
26757 (char *) "win", NULL
26758 };
26759
26760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26761 if (obj0) {
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26765 }
26766 arg1 = reinterpret_cast< wxWindow * >(argp1);
26767 }
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26784 wxWindow *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject *swig_obj[1] ;
26788
26789 if (!args) SWIG_fail;
26790 swig_obj[0] = args;
26791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26792 if (!SWIG_IsOK(res1)) {
26793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26794 }
26795 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 resultobj = wxPyMake_wxObject(result, (bool)0);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26812 PyObject *obj;
26813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26814 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26815 return SWIG_Py_Void();
26816 }
26817
26818 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26819 return SWIG_Python_InitShadowInstance(args);
26820 }
26821
26822 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26823 PyObject *resultobj = 0;
26824 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26825 bool arg2 = (bool) true ;
26826 int arg3 = (int) 0 ;
26827 wxActivateEvent *result = 0 ;
26828 int val1 ;
26829 int ecode1 = 0 ;
26830 bool val2 ;
26831 int ecode2 = 0 ;
26832 int val3 ;
26833 int ecode3 = 0 ;
26834 PyObject * obj0 = 0 ;
26835 PyObject * obj1 = 0 ;
26836 PyObject * obj2 = 0 ;
26837 char * kwnames[] = {
26838 (char *) "type",(char *) "active",(char *) "Id", NULL
26839 };
26840
26841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26842 if (obj0) {
26843 ecode1 = SWIG_AsVal_int(obj0, &val1);
26844 if (!SWIG_IsOK(ecode1)) {
26845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26846 }
26847 arg1 = static_cast< wxEventType >(val1);
26848 }
26849 if (obj1) {
26850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26851 if (!SWIG_IsOK(ecode2)) {
26852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26853 }
26854 arg2 = static_cast< bool >(val2);
26855 }
26856 if (obj2) {
26857 ecode3 = SWIG_AsVal_int(obj2, &val3);
26858 if (!SWIG_IsOK(ecode3)) {
26859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26860 }
26861 arg3 = static_cast< int >(val3);
26862 }
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26866 wxPyEndAllowThreads(__tstate);
26867 if (PyErr_Occurred()) SWIG_fail;
26868 }
26869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26870 return resultobj;
26871 fail:
26872 return NULL;
26873 }
26874
26875
26876 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26877 PyObject *resultobj = 0;
26878 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26879 bool result;
26880 void *argp1 = 0 ;
26881 int res1 = 0 ;
26882 PyObject *swig_obj[1] ;
26883
26884 if (!args) SWIG_fail;
26885 swig_obj[0] = args;
26886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26887 if (!SWIG_IsOK(res1)) {
26888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26889 }
26890 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26891 {
26892 PyThreadState* __tstate = wxPyBeginAllowThreads();
26893 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26894 wxPyEndAllowThreads(__tstate);
26895 if (PyErr_Occurred()) SWIG_fail;
26896 }
26897 {
26898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26899 }
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26907 PyObject *obj;
26908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26909 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26910 return SWIG_Py_Void();
26911 }
26912
26913 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26914 return SWIG_Python_InitShadowInstance(args);
26915 }
26916
26917 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj = 0;
26919 int arg1 = (int) 0 ;
26920 wxInitDialogEvent *result = 0 ;
26921 int val1 ;
26922 int ecode1 = 0 ;
26923 PyObject * obj0 = 0 ;
26924 char * kwnames[] = {
26925 (char *) "Id", NULL
26926 };
26927
26928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26929 if (obj0) {
26930 ecode1 = SWIG_AsVal_int(obj0, &val1);
26931 if (!SWIG_IsOK(ecode1)) {
26932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26933 }
26934 arg1 = static_cast< int >(val1);
26935 }
26936 {
26937 PyThreadState* __tstate = wxPyBeginAllowThreads();
26938 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26939 wxPyEndAllowThreads(__tstate);
26940 if (PyErr_Occurred()) SWIG_fail;
26941 }
26942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26943 return resultobj;
26944 fail:
26945 return NULL;
26946 }
26947
26948
26949 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26950 PyObject *obj;
26951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26952 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26953 return SWIG_Py_Void();
26954 }
26955
26956 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26957 return SWIG_Python_InitShadowInstance(args);
26958 }
26959
26960 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj = 0;
26962 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26963 int arg2 = (int) 0 ;
26964 wxMenu *arg3 = (wxMenu *) NULL ;
26965 wxMenuEvent *result = 0 ;
26966 int val1 ;
26967 int ecode1 = 0 ;
26968 int val2 ;
26969 int ecode2 = 0 ;
26970 void *argp3 = 0 ;
26971 int res3 = 0 ;
26972 PyObject * obj0 = 0 ;
26973 PyObject * obj1 = 0 ;
26974 PyObject * obj2 = 0 ;
26975 char * kwnames[] = {
26976 (char *) "type",(char *) "winid",(char *) "menu", NULL
26977 };
26978
26979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26980 if (obj0) {
26981 ecode1 = SWIG_AsVal_int(obj0, &val1);
26982 if (!SWIG_IsOK(ecode1)) {
26983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26984 }
26985 arg1 = static_cast< wxEventType >(val1);
26986 }
26987 if (obj1) {
26988 ecode2 = SWIG_AsVal_int(obj1, &val2);
26989 if (!SWIG_IsOK(ecode2)) {
26990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26991 }
26992 arg2 = static_cast< int >(val2);
26993 }
26994 if (obj2) {
26995 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26996 if (!SWIG_IsOK(res3)) {
26997 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26998 }
26999 arg3 = reinterpret_cast< wxMenu * >(argp3);
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27015 PyObject *resultobj = 0;
27016 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27017 int result;
27018 void *argp1 = 0 ;
27019 int res1 = 0 ;
27020 PyObject *swig_obj[1] ;
27021
27022 if (!args) SWIG_fail;
27023 swig_obj[0] = args;
27024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27025 if (!SWIG_IsOK(res1)) {
27026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27027 }
27028 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 resultobj = SWIG_From_int(static_cast< int >(result));
27036 return resultobj;
27037 fail:
27038 return NULL;
27039 }
27040
27041
27042 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 PyObject *resultobj = 0;
27044 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27045 bool result;
27046 void *argp1 = 0 ;
27047 int res1 = 0 ;
27048 PyObject *swig_obj[1] ;
27049
27050 if (!args) SWIG_fail;
27051 swig_obj[0] = args;
27052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27053 if (!SWIG_IsOK(res1)) {
27054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27055 }
27056 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 {
27064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27065 }
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27073 PyObject *resultobj = 0;
27074 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27075 wxMenu *result = 0 ;
27076 void *argp1 = 0 ;
27077 int res1 = 0 ;
27078 PyObject *swig_obj[1] ;
27079
27080 if (!args) SWIG_fail;
27081 swig_obj[0] = args;
27082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27083 if (!SWIG_IsOK(res1)) {
27084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27085 }
27086 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 {
27094 resultobj = wxPyMake_wxObject(result, (bool)0);
27095 }
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27103 PyObject *obj;
27104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27105 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27106 return SWIG_Py_Void();
27107 }
27108
27109 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27110 return SWIG_Python_InitShadowInstance(args);
27111 }
27112
27113 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27114 PyObject *resultobj = 0;
27115 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27116 int arg2 = (int) 0 ;
27117 wxCloseEvent *result = 0 ;
27118 int val1 ;
27119 int ecode1 = 0 ;
27120 int val2 ;
27121 int ecode2 = 0 ;
27122 PyObject * obj0 = 0 ;
27123 PyObject * obj1 = 0 ;
27124 char * kwnames[] = {
27125 (char *) "type",(char *) "winid", NULL
27126 };
27127
27128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27129 if (obj0) {
27130 ecode1 = SWIG_AsVal_int(obj0, &val1);
27131 if (!SWIG_IsOK(ecode1)) {
27132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27133 }
27134 arg1 = static_cast< wxEventType >(val1);
27135 }
27136 if (obj1) {
27137 ecode2 = SWIG_AsVal_int(obj1, &val2);
27138 if (!SWIG_IsOK(ecode2)) {
27139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27140 }
27141 arg2 = static_cast< int >(val2);
27142 }
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj = 0;
27158 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27159 bool arg2 ;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 bool val2 ;
27163 int ecode2 = 0 ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "logOff", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27174 }
27175 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27176 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27177 if (!SWIG_IsOK(ecode2)) {
27178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27179 }
27180 arg2 = static_cast< bool >(val2);
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 (arg1)->SetLoggingOff(arg2);
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 resultobj = SWIG_Py_Void();
27188 return resultobj;
27189 fail:
27190 return NULL;
27191 }
27192
27193
27194 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27195 PyObject *resultobj = 0;
27196 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27197 bool result;
27198 void *argp1 = 0 ;
27199 int res1 = 0 ;
27200 PyObject *swig_obj[1] ;
27201
27202 if (!args) SWIG_fail;
27203 swig_obj[0] = args;
27204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27205 if (!SWIG_IsOK(res1)) {
27206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27207 }
27208 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27212 wxPyEndAllowThreads(__tstate);
27213 if (PyErr_Occurred()) SWIG_fail;
27214 }
27215 {
27216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27217 }
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj = 0;
27226 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27227 bool arg2 = (bool) true ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 bool val2 ;
27231 int ecode2 = 0 ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 char * kwnames[] = {
27235 (char *) "self",(char *) "veto", NULL
27236 };
27237
27238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27240 if (!SWIG_IsOK(res1)) {
27241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27242 }
27243 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27244 if (obj1) {
27245 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27246 if (!SWIG_IsOK(ecode2)) {
27247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27248 }
27249 arg2 = static_cast< bool >(val2);
27250 }
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->Veto(arg2);
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 resultobj = SWIG_Py_Void();
27258 return resultobj;
27259 fail:
27260 return NULL;
27261 }
27262
27263
27264 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27265 PyObject *resultobj = 0;
27266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27267 bool result;
27268 void *argp1 = 0 ;
27269 int res1 = 0 ;
27270 PyObject *swig_obj[1] ;
27271
27272 if (!args) SWIG_fail;
27273 swig_obj[0] = args;
27274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27275 if (!SWIG_IsOK(res1)) {
27276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27277 }
27278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 {
27286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27287 }
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj = 0;
27296 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27297 bool arg2 ;
27298 void *argp1 = 0 ;
27299 int res1 = 0 ;
27300 bool val2 ;
27301 int ecode2 = 0 ;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 char * kwnames[] = {
27305 (char *) "self",(char *) "canVeto", NULL
27306 };
27307
27308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27310 if (!SWIG_IsOK(res1)) {
27311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27312 }
27313 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27315 if (!SWIG_IsOK(ecode2)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27317 }
27318 arg2 = static_cast< bool >(val2);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 (arg1)->SetCanVeto(arg2);
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_Py_Void();
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27335 bool result;
27336 void *argp1 = 0 ;
27337 int res1 = 0 ;
27338 PyObject *swig_obj[1] ;
27339
27340 if (!args) SWIG_fail;
27341 swig_obj[0] = args;
27342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27345 }
27346 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 {
27354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27355 }
27356 return resultobj;
27357 fail:
27358 return NULL;
27359 }
27360
27361
27362 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27363 PyObject *obj;
27364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27365 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27366 return SWIG_Py_Void();
27367 }
27368
27369 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27370 return SWIG_Python_InitShadowInstance(args);
27371 }
27372
27373 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj = 0;
27375 int arg1 = (int) 0 ;
27376 bool arg2 = (bool) false ;
27377 wxShowEvent *result = 0 ;
27378 int val1 ;
27379 int ecode1 = 0 ;
27380 bool val2 ;
27381 int ecode2 = 0 ;
27382 PyObject * obj0 = 0 ;
27383 PyObject * obj1 = 0 ;
27384 char * kwnames[] = {
27385 (char *) "winid",(char *) "show", NULL
27386 };
27387
27388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27389 if (obj0) {
27390 ecode1 = SWIG_AsVal_int(obj0, &val1);
27391 if (!SWIG_IsOK(ecode1)) {
27392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27393 }
27394 arg1 = static_cast< int >(val1);
27395 }
27396 if (obj1) {
27397 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27398 if (!SWIG_IsOK(ecode2)) {
27399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27400 }
27401 arg2 = static_cast< bool >(val2);
27402 }
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = 0;
27418 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27419 bool arg2 ;
27420 void *argp1 = 0 ;
27421 int res1 = 0 ;
27422 bool val2 ;
27423 int ecode2 = 0 ;
27424 PyObject * obj0 = 0 ;
27425 PyObject * obj1 = 0 ;
27426 char * kwnames[] = {
27427 (char *) "self",(char *) "show", NULL
27428 };
27429
27430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27432 if (!SWIG_IsOK(res1)) {
27433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27434 }
27435 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27437 if (!SWIG_IsOK(ecode2)) {
27438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27439 }
27440 arg2 = static_cast< bool >(val2);
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 (arg1)->SetShow(arg2);
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_Py_Void();
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27457 bool result;
27458 void *argp1 = 0 ;
27459 int res1 = 0 ;
27460 PyObject *swig_obj[1] ;
27461
27462 if (!args) SWIG_fail;
27463 swig_obj[0] = args;
27464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27465 if (!SWIG_IsOK(res1)) {
27466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27467 }
27468 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 {
27476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27477 }
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27485 PyObject *obj;
27486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27487 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27488 return SWIG_Py_Void();
27489 }
27490
27491 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27492 return SWIG_Python_InitShadowInstance(args);
27493 }
27494
27495 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj = 0;
27497 int arg1 = (int) 0 ;
27498 bool arg2 = (bool) true ;
27499 wxIconizeEvent *result = 0 ;
27500 int val1 ;
27501 int ecode1 = 0 ;
27502 bool val2 ;
27503 int ecode2 = 0 ;
27504 PyObject * obj0 = 0 ;
27505 PyObject * obj1 = 0 ;
27506 char * kwnames[] = {
27507 (char *) "id",(char *) "iconized", NULL
27508 };
27509
27510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27511 if (obj0) {
27512 ecode1 = SWIG_AsVal_int(obj0, &val1);
27513 if (!SWIG_IsOK(ecode1)) {
27514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27515 }
27516 arg1 = static_cast< int >(val1);
27517 }
27518 if (obj1) {
27519 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27520 if (!SWIG_IsOK(ecode2)) {
27521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27522 }
27523 arg2 = static_cast< bool >(val2);
27524 }
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27539 PyObject *resultobj = 0;
27540 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27541 bool result;
27542 void *argp1 = 0 ;
27543 int res1 = 0 ;
27544 PyObject *swig_obj[1] ;
27545
27546 if (!args) SWIG_fail;
27547 swig_obj[0] = args;
27548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27551 }
27552 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 result = (bool)(arg1)->Iconized();
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 {
27560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27561 }
27562 return resultobj;
27563 fail:
27564 return NULL;
27565 }
27566
27567
27568 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27569 PyObject *obj;
27570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27571 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27572 return SWIG_Py_Void();
27573 }
27574
27575 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27576 return SWIG_Python_InitShadowInstance(args);
27577 }
27578
27579 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj = 0;
27581 int arg1 = (int) 0 ;
27582 wxMaximizeEvent *result = 0 ;
27583 int val1 ;
27584 int ecode1 = 0 ;
27585 PyObject * obj0 = 0 ;
27586 char * kwnames[] = {
27587 (char *) "id", NULL
27588 };
27589
27590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27591 if (obj0) {
27592 ecode1 = SWIG_AsVal_int(obj0, &val1);
27593 if (!SWIG_IsOK(ecode1)) {
27594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27595 }
27596 arg1 = static_cast< int >(val1);
27597 }
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *obj;
27613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27614 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27615 return SWIG_Py_Void();
27616 }
27617
27618 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27619 return SWIG_Python_InitShadowInstance(args);
27620 }
27621
27622 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27623 PyObject *resultobj = 0;
27624 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27625 wxPoint result;
27626 void *argp1 = 0 ;
27627 int res1 = 0 ;
27628 PyObject *swig_obj[1] ;
27629
27630 if (!args) SWIG_fail;
27631 swig_obj[0] = args;
27632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27633 if (!SWIG_IsOK(res1)) {
27634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27635 }
27636 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 result = (arg1)->GetPosition();
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 PyObject *resultobj = 0;
27652 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27653 int result;
27654 void *argp1 = 0 ;
27655 int res1 = 0 ;
27656 PyObject *swig_obj[1] ;
27657
27658 if (!args) SWIG_fail;
27659 swig_obj[0] = args;
27660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27661 if (!SWIG_IsOK(res1)) {
27662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27663 }
27664 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 result = (int)(arg1)->GetNumberOfFiles();
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 resultobj = SWIG_From_int(static_cast< int >(result));
27672 return resultobj;
27673 fail:
27674 return NULL;
27675 }
27676
27677
27678 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 PyObject *resultobj = 0;
27680 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27681 PyObject *result = 0 ;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27691 }
27692 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 resultobj = result;
27700 return resultobj;
27701 fail:
27702 return NULL;
27703 }
27704
27705
27706 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27707 PyObject *obj;
27708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27709 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27710 return SWIG_Py_Void();
27711 }
27712
27713 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27714 PyObject *resultobj = 0;
27715 int arg1 = (int) 0 ;
27716 wxUpdateUIEvent *result = 0 ;
27717 int val1 ;
27718 int ecode1 = 0 ;
27719 PyObject * obj0 = 0 ;
27720 char * kwnames[] = {
27721 (char *) "commandId", NULL
27722 };
27723
27724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27725 if (obj0) {
27726 ecode1 = SWIG_AsVal_int(obj0, &val1);
27727 if (!SWIG_IsOK(ecode1)) {
27728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27729 }
27730 arg1 = static_cast< int >(val1);
27731 }
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27748 bool result;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27758 }
27759 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 {
27767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27778 bool result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 PyObject *swig_obj[1] ;
27782
27783 if (!args) SWIG_fail;
27784 swig_obj[0] = args;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27788 }
27789 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 {
27797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27798 }
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27806 PyObject *resultobj = 0;
27807 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27808 bool result;
27809 void *argp1 = 0 ;
27810 int res1 = 0 ;
27811 PyObject *swig_obj[1] ;
27812
27813 if (!args) SWIG_fail;
27814 swig_obj[0] = args;
27815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27816 if (!SWIG_IsOK(res1)) {
27817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27818 }
27819 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 {
27827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27828 }
27829 return resultobj;
27830 fail:
27831 return NULL;
27832 }
27833
27834
27835 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27836 PyObject *resultobj = 0;
27837 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27838 wxString result;
27839 void *argp1 = 0 ;
27840 int res1 = 0 ;
27841 PyObject *swig_obj[1] ;
27842
27843 if (!args) SWIG_fail;
27844 swig_obj[0] = args;
27845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27846 if (!SWIG_IsOK(res1)) {
27847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27848 }
27849 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 {
27857 #if wxUSE_UNICODE
27858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27859 #else
27860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27861 #endif
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27870 PyObject *resultobj = 0;
27871 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27872 bool result;
27873 void *argp1 = 0 ;
27874 int res1 = 0 ;
27875 PyObject *swig_obj[1] ;
27876
27877 if (!args) SWIG_fail;
27878 swig_obj[0] = args;
27879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27880 if (!SWIG_IsOK(res1)) {
27881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27882 }
27883 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27902 bool result;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 PyObject *swig_obj[1] ;
27906
27907 if (!args) SWIG_fail;
27908 swig_obj[0] = args;
27909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27912 }
27913 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 {
27921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27922 }
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27930 PyObject *resultobj = 0;
27931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27932 bool result;
27933 void *argp1 = 0 ;
27934 int res1 = 0 ;
27935 PyObject *swig_obj[1] ;
27936
27937 if (!args) SWIG_fail;
27938 swig_obj[0] = args;
27939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27940 if (!SWIG_IsOK(res1)) {
27941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27942 }
27943 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 {
27951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27960 PyObject *resultobj = 0;
27961 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27962 bool result;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 PyObject *swig_obj[1] ;
27966
27967 if (!args) SWIG_fail;
27968 swig_obj[0] = args;
27969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27970 if (!SWIG_IsOK(res1)) {
27971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27972 }
27973 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj = 0;
27991 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27992 bool arg2 ;
27993 void *argp1 = 0 ;
27994 int res1 = 0 ;
27995 bool val2 ;
27996 int ecode2 = 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char * kwnames[] = {
28000 (char *) "self",(char *) "check", NULL
28001 };
28002
28003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28005 if (!SWIG_IsOK(res1)) {
28006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28007 }
28008 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28009 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28010 if (!SWIG_IsOK(ecode2)) {
28011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28012 }
28013 arg2 = static_cast< bool >(val2);
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 (arg1)->Check(arg2);
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 resultobj = SWIG_Py_Void();
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28028 PyObject *resultobj = 0;
28029 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28030 bool arg2 ;
28031 void *argp1 = 0 ;
28032 int res1 = 0 ;
28033 bool val2 ;
28034 int ecode2 = 0 ;
28035 PyObject * obj0 = 0 ;
28036 PyObject * obj1 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "self",(char *) "enable", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28043 if (!SWIG_IsOK(res1)) {
28044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28045 }
28046 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28048 if (!SWIG_IsOK(ecode2)) {
28049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28050 }
28051 arg2 = static_cast< bool >(val2);
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 (arg1)->Enable(arg2);
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 resultobj = SWIG_Py_Void();
28059 return resultobj;
28060 fail:
28061 return NULL;
28062 }
28063
28064
28065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj = 0;
28067 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28068 bool arg2 ;
28069 void *argp1 = 0 ;
28070 int res1 = 0 ;
28071 bool val2 ;
28072 int ecode2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "self",(char *) "show", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28081 if (!SWIG_IsOK(res1)) {
28082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28083 }
28084 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28085 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28086 if (!SWIG_IsOK(ecode2)) {
28087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28088 }
28089 arg2 = static_cast< bool >(val2);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 (arg1)->Show(arg2);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28106 wxString *arg2 = 0 ;
28107 void *argp1 = 0 ;
28108 int res1 = 0 ;
28109 bool temp2 = false ;
28110 PyObject * obj0 = 0 ;
28111 PyObject * obj1 = 0 ;
28112 char * kwnames[] = {
28113 (char *) "self",(char *) "text", NULL
28114 };
28115
28116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28118 if (!SWIG_IsOK(res1)) {
28119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28120 }
28121 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28122 {
28123 arg2 = wxString_in_helper(obj1);
28124 if (arg2 == NULL) SWIG_fail;
28125 temp2 = true;
28126 }
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 (arg1)->SetText((wxString const &)*arg2);
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 resultobj = SWIG_Py_Void();
28134 {
28135 if (temp2)
28136 delete arg2;
28137 }
28138 return resultobj;
28139 fail:
28140 {
28141 if (temp2)
28142 delete arg2;
28143 }
28144 return NULL;
28145 }
28146
28147
28148 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28149 PyObject *resultobj = 0;
28150 long arg1 ;
28151 long val1 ;
28152 int ecode1 = 0 ;
28153 PyObject * obj0 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "updateInterval", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28159 ecode1 = SWIG_AsVal_long(obj0, &val1);
28160 if (!SWIG_IsOK(ecode1)) {
28161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28162 }
28163 arg1 = static_cast< long >(val1);
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 wxUpdateUIEvent::SetUpdateInterval(arg1);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_Py_Void();
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28178 PyObject *resultobj = 0;
28179 long result;
28180
28181 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28185 wxPyEndAllowThreads(__tstate);
28186 if (PyErr_Occurred()) SWIG_fail;
28187 }
28188 resultobj = SWIG_From_long(static_cast< long >(result));
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj = 0;
28197 wxWindow *arg1 = (wxWindow *) 0 ;
28198 bool result;
28199 void *argp1 = 0 ;
28200 int res1 = 0 ;
28201 PyObject * obj0 = 0 ;
28202 char * kwnames[] = {
28203 (char *) "win", NULL
28204 };
28205
28206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28208 if (!SWIG_IsOK(res1)) {
28209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28210 }
28211 arg1 = reinterpret_cast< wxWindow * >(argp1);
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 {
28219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28220 }
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28228 PyObject *resultobj = 0;
28229
28230 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28231 {
28232 PyThreadState* __tstate = wxPyBeginAllowThreads();
28233 wxUpdateUIEvent::ResetUpdateTime();
28234 wxPyEndAllowThreads(__tstate);
28235 if (PyErr_Occurred()) SWIG_fail;
28236 }
28237 resultobj = SWIG_Py_Void();
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = 0;
28246 wxUpdateUIMode arg1 ;
28247 int val1 ;
28248 int ecode1 = 0 ;
28249 PyObject * obj0 = 0 ;
28250 char * kwnames[] = {
28251 (char *) "mode", NULL
28252 };
28253
28254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28255 ecode1 = SWIG_AsVal_int(obj0, &val1);
28256 if (!SWIG_IsOK(ecode1)) {
28257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28258 }
28259 arg1 = static_cast< wxUpdateUIMode >(val1);
28260 {
28261 PyThreadState* __tstate = wxPyBeginAllowThreads();
28262 wxUpdateUIEvent::SetMode(arg1);
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_Py_Void();
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28274 PyObject *resultobj = 0;
28275 wxUpdateUIMode result;
28276
28277 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_From_int(static_cast< int >(result));
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *obj;
28293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28294 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28295 return SWIG_Py_Void();
28296 }
28297
28298 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 return SWIG_Python_InitShadowInstance(args);
28300 }
28301
28302 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28303 PyObject *resultobj = 0;
28304 wxSysColourChangedEvent *result = 0 ;
28305
28306 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28307 {
28308 PyThreadState* __tstate = wxPyBeginAllowThreads();
28309 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28310 wxPyEndAllowThreads(__tstate);
28311 if (PyErr_Occurred()) SWIG_fail;
28312 }
28313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28314 return resultobj;
28315 fail:
28316 return NULL;
28317 }
28318
28319
28320 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28321 PyObject *obj;
28322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28323 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28324 return SWIG_Py_Void();
28325 }
28326
28327 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 return SWIG_Python_InitShadowInstance(args);
28329 }
28330
28331 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj = 0;
28333 int arg1 = (int) 0 ;
28334 wxWindow *arg2 = (wxWindow *) NULL ;
28335 wxMouseCaptureChangedEvent *result = 0 ;
28336 int val1 ;
28337 int ecode1 = 0 ;
28338 void *argp2 = 0 ;
28339 int res2 = 0 ;
28340 PyObject * obj0 = 0 ;
28341 PyObject * obj1 = 0 ;
28342 char * kwnames[] = {
28343 (char *) "winid",(char *) "gainedCapture", NULL
28344 };
28345
28346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28347 if (obj0) {
28348 ecode1 = SWIG_AsVal_int(obj0, &val1);
28349 if (!SWIG_IsOK(ecode1)) {
28350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28351 }
28352 arg1 = static_cast< int >(val1);
28353 }
28354 if (obj1) {
28355 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28356 if (!SWIG_IsOK(res2)) {
28357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28358 }
28359 arg2 = reinterpret_cast< wxWindow * >(argp2);
28360 }
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28377 wxWindow *result = 0 ;
28378 void *argp1 = 0 ;
28379 int res1 = 0 ;
28380 PyObject *swig_obj[1] ;
28381
28382 if (!args) SWIG_fail;
28383 swig_obj[0] = args;
28384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28385 if (!SWIG_IsOK(res1)) {
28386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28387 }
28388 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 resultobj = wxPyMake_wxObject(result, (bool)0);
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28405 PyObject *obj;
28406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28407 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28408 return SWIG_Py_Void();
28409 }
28410
28411 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28412 return SWIG_Python_InitShadowInstance(args);
28413 }
28414
28415 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj = 0;
28417 int arg1 = (int) 0 ;
28418 wxMouseCaptureLostEvent *result = 0 ;
28419 int val1 ;
28420 int ecode1 = 0 ;
28421 PyObject * obj0 = 0 ;
28422 char * kwnames[] = {
28423 (char *) "winid", NULL
28424 };
28425
28426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28427 if (obj0) {
28428 ecode1 = SWIG_AsVal_int(obj0, &val1);
28429 if (!SWIG_IsOK(ecode1)) {
28430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28431 }
28432 arg1 = static_cast< int >(val1);
28433 }
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28448 PyObject *obj;
28449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28450 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28451 return SWIG_Py_Void();
28452 }
28453
28454 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 return SWIG_Python_InitShadowInstance(args);
28456 }
28457
28458 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 PyObject *resultobj = 0;
28460 wxDisplayChangedEvent *result = 0 ;
28461
28462 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28477 PyObject *obj;
28478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28479 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28480 return SWIG_Py_Void();
28481 }
28482
28483 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28484 return SWIG_Python_InitShadowInstance(args);
28485 }
28486
28487 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28488 PyObject *resultobj = 0;
28489 int arg1 = (int) 0 ;
28490 wxPaletteChangedEvent *result = 0 ;
28491 int val1 ;
28492 int ecode1 = 0 ;
28493 PyObject * obj0 = 0 ;
28494 char * kwnames[] = {
28495 (char *) "id", NULL
28496 };
28497
28498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28499 if (obj0) {
28500 ecode1 = SWIG_AsVal_int(obj0, &val1);
28501 if (!SWIG_IsOK(ecode1)) {
28502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28503 }
28504 arg1 = static_cast< int >(val1);
28505 }
28506 {
28507 PyThreadState* __tstate = wxPyBeginAllowThreads();
28508 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = 0;
28521 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28522 wxWindow *arg2 = (wxWindow *) 0 ;
28523 void *argp1 = 0 ;
28524 int res1 = 0 ;
28525 void *argp2 = 0 ;
28526 int res2 = 0 ;
28527 PyObject * obj0 = 0 ;
28528 PyObject * obj1 = 0 ;
28529 char * kwnames[] = {
28530 (char *) "self",(char *) "win", NULL
28531 };
28532
28533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28535 if (!SWIG_IsOK(res1)) {
28536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28537 }
28538 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28540 if (!SWIG_IsOK(res2)) {
28541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28542 }
28543 arg2 = reinterpret_cast< wxWindow * >(argp2);
28544 {
28545 PyThreadState* __tstate = wxPyBeginAllowThreads();
28546 (arg1)->SetChangedWindow(arg2);
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 resultobj = SWIG_Py_Void();
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28558 PyObject *resultobj = 0;
28559 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28560 wxWindow *result = 0 ;
28561 void *argp1 = 0 ;
28562 int res1 = 0 ;
28563 PyObject *swig_obj[1] ;
28564
28565 if (!args) SWIG_fail;
28566 swig_obj[0] = args;
28567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28570 }
28571 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (wxWindow *)(arg1)->GetChangedWindow();
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 {
28579 resultobj = wxPyMake_wxObject(result, (bool)0);
28580 }
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28588 PyObject *obj;
28589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28590 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28591 return SWIG_Py_Void();
28592 }
28593
28594 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28595 return SWIG_Python_InitShadowInstance(args);
28596 }
28597
28598 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28599 PyObject *resultobj = 0;
28600 int arg1 = (int) 0 ;
28601 wxQueryNewPaletteEvent *result = 0 ;
28602 int val1 ;
28603 int ecode1 = 0 ;
28604 PyObject * obj0 = 0 ;
28605 char * kwnames[] = {
28606 (char *) "winid", NULL
28607 };
28608
28609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28610 if (obj0) {
28611 ecode1 = SWIG_AsVal_int(obj0, &val1);
28612 if (!SWIG_IsOK(ecode1)) {
28613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28614 }
28615 arg1 = static_cast< int >(val1);
28616 }
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28631 PyObject *resultobj = 0;
28632 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28633 bool arg2 ;
28634 void *argp1 = 0 ;
28635 int res1 = 0 ;
28636 bool val2 ;
28637 int ecode2 = 0 ;
28638 PyObject * obj0 = 0 ;
28639 PyObject * obj1 = 0 ;
28640 char * kwnames[] = {
28641 (char *) "self",(char *) "realized", NULL
28642 };
28643
28644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28646 if (!SWIG_IsOK(res1)) {
28647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28648 }
28649 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28650 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28651 if (!SWIG_IsOK(ecode2)) {
28652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28653 }
28654 arg2 = static_cast< bool >(val2);
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 (arg1)->SetPaletteRealized(arg2);
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_Py_Void();
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *resultobj = 0;
28670 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28671 bool result;
28672 void *argp1 = 0 ;
28673 int res1 = 0 ;
28674 PyObject *swig_obj[1] ;
28675
28676 if (!args) SWIG_fail;
28677 swig_obj[0] = args;
28678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28679 if (!SWIG_IsOK(res1)) {
28680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28681 }
28682 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 {
28690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28691 }
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28699 PyObject *obj;
28700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28701 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28702 return SWIG_Py_Void();
28703 }
28704
28705 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28706 return SWIG_Python_InitShadowInstance(args);
28707 }
28708
28709 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710 PyObject *resultobj = 0;
28711 wxNavigationKeyEvent *result = 0 ;
28712
28713 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 PyObject *resultobj = 0;
28729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28730 bool result;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 PyObject *swig_obj[1] ;
28734
28735 if (!args) SWIG_fail;
28736 swig_obj[0] = args;
28737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28740 }
28741 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28750 }
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = 0;
28759 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28760 bool arg2 ;
28761 void *argp1 = 0 ;
28762 int res1 = 0 ;
28763 bool val2 ;
28764 int ecode2 = 0 ;
28765 PyObject * obj0 = 0 ;
28766 PyObject * obj1 = 0 ;
28767 char * kwnames[] = {
28768 (char *) "self",(char *) "forward", NULL
28769 };
28770
28771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28773 if (!SWIG_IsOK(res1)) {
28774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28775 }
28776 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28778 if (!SWIG_IsOK(ecode2)) {
28779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28780 }
28781 arg2 = static_cast< bool >(val2);
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 (arg1)->SetDirection(arg2);
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_Py_Void();
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28798 bool result;
28799 void *argp1 = 0 ;
28800 int res1 = 0 ;
28801 PyObject *swig_obj[1] ;
28802
28803 if (!args) SWIG_fail;
28804 swig_obj[0] = args;
28805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28808 }
28809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 {
28817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28818 }
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28826 PyObject *resultobj = 0;
28827 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28828 bool arg2 ;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 bool val2 ;
28832 int ecode2 = 0 ;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 char * kwnames[] = {
28836 (char *) "self",(char *) "ischange", NULL
28837 };
28838
28839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28841 if (!SWIG_IsOK(res1)) {
28842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28843 }
28844 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28846 if (!SWIG_IsOK(ecode2)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28848 }
28849 arg2 = static_cast< bool >(val2);
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 (arg1)->SetWindowChange(arg2);
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_Py_Void();
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28864 PyObject *resultobj = 0;
28865 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28866 bool result;
28867 void *argp1 = 0 ;
28868 int res1 = 0 ;
28869 PyObject *swig_obj[1] ;
28870
28871 if (!args) SWIG_fail;
28872 swig_obj[0] = args;
28873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28874 if (!SWIG_IsOK(res1)) {
28875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28876 }
28877 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 {
28885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28886 }
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28894 PyObject *resultobj = 0;
28895 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28896 bool arg2 ;
28897 void *argp1 = 0 ;
28898 int res1 = 0 ;
28899 bool val2 ;
28900 int ecode2 = 0 ;
28901 PyObject * obj0 = 0 ;
28902 PyObject * obj1 = 0 ;
28903 char * kwnames[] = {
28904 (char *) "self",(char *) "bIs", NULL
28905 };
28906
28907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28911 }
28912 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28914 if (!SWIG_IsOK(ecode2)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28916 }
28917 arg2 = static_cast< bool >(val2);
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 (arg1)->SetFromTab(arg2);
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_Py_Void();
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj = 0;
28933 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28934 long arg2 ;
28935 void *argp1 = 0 ;
28936 int res1 = 0 ;
28937 long val2 ;
28938 int ecode2 = 0 ;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 char * kwnames[] = {
28942 (char *) "self",(char *) "flags", NULL
28943 };
28944
28945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28947 if (!SWIG_IsOK(res1)) {
28948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28949 }
28950 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28951 ecode2 = SWIG_AsVal_long(obj1, &val2);
28952 if (!SWIG_IsOK(ecode2)) {
28953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28954 }
28955 arg2 = static_cast< long >(val2);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 (arg1)->SetFlags(arg2);
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28972 wxWindow *result = 0 ;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 PyObject *swig_obj[1] ;
28976
28977 if (!args) SWIG_fail;
28978 swig_obj[0] = args;
28979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28982 }
28983 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 {
28991 resultobj = wxPyMake_wxObject(result, (bool)0);
28992 }
28993 return resultobj;
28994 fail:
28995 return NULL;
28996 }
28997
28998
28999 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29000 PyObject *resultobj = 0;
29001 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29002 wxWindow *arg2 = (wxWindow *) 0 ;
29003 void *argp1 = 0 ;
29004 int res1 = 0 ;
29005 void *argp2 = 0 ;
29006 int res2 = 0 ;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 char * kwnames[] = {
29010 (char *) "self",(char *) "win", NULL
29011 };
29012
29013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29015 if (!SWIG_IsOK(res1)) {
29016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29017 }
29018 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29020 if (!SWIG_IsOK(res2)) {
29021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29022 }
29023 arg2 = reinterpret_cast< wxWindow * >(argp2);
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 (arg1)->SetCurrentFocus(arg2);
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_Py_Void();
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *obj;
29039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29040 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29041 return SWIG_Py_Void();
29042 }
29043
29044 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29045 return SWIG_Python_InitShadowInstance(args);
29046 }
29047
29048 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29049 PyObject *resultobj = 0;
29050 wxWindow *arg1 = (wxWindow *) NULL ;
29051 wxWindowCreateEvent *result = 0 ;
29052 void *argp1 = 0 ;
29053 int res1 = 0 ;
29054 PyObject * obj0 = 0 ;
29055 char * kwnames[] = {
29056 (char *) "win", NULL
29057 };
29058
29059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29060 if (obj0) {
29061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29062 if (!SWIG_IsOK(res1)) {
29063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29064 }
29065 arg1 = reinterpret_cast< wxWindow * >(argp1);
29066 }
29067 {
29068 PyThreadState* __tstate = wxPyBeginAllowThreads();
29069 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29070 wxPyEndAllowThreads(__tstate);
29071 if (PyErr_Occurred()) SWIG_fail;
29072 }
29073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29074 return resultobj;
29075 fail:
29076 return NULL;
29077 }
29078
29079
29080 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29081 PyObject *resultobj = 0;
29082 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29083 wxWindow *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 PyObject *swig_obj[1] ;
29087
29088 if (!args) SWIG_fail;
29089 swig_obj[0] = args;
29090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29091 if (!SWIG_IsOK(res1)) {
29092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29093 }
29094 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 {
29102 resultobj = wxPyMake_wxObject(result, (bool)0);
29103 }
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29111 PyObject *obj;
29112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29113 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29114 return SWIG_Py_Void();
29115 }
29116
29117 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29118 return SWIG_Python_InitShadowInstance(args);
29119 }
29120
29121 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 wxWindow *arg1 = (wxWindow *) NULL ;
29124 wxWindowDestroyEvent *result = 0 ;
29125 void *argp1 = 0 ;
29126 int res1 = 0 ;
29127 PyObject * obj0 = 0 ;
29128 char * kwnames[] = {
29129 (char *) "win", NULL
29130 };
29131
29132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29133 if (obj0) {
29134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29135 if (!SWIG_IsOK(res1)) {
29136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29137 }
29138 arg1 = reinterpret_cast< wxWindow * >(argp1);
29139 }
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29147 return resultobj;
29148 fail:
29149 return NULL;
29150 }
29151
29152
29153 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29154 PyObject *resultobj = 0;
29155 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29156 wxWindow *result = 0 ;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 PyObject *swig_obj[1] ;
29160
29161 if (!args) SWIG_fail;
29162 swig_obj[0] = args;
29163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29164 if (!SWIG_IsOK(res1)) {
29165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29166 }
29167 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 {
29175 resultobj = wxPyMake_wxObject(result, (bool)0);
29176 }
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29184 PyObject *obj;
29185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29186 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29187 return SWIG_Py_Void();
29188 }
29189
29190 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 return SWIG_Python_InitShadowInstance(args);
29192 }
29193
29194 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj = 0;
29196 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29197 int arg2 = (int) 0 ;
29198 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29199 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29200 wxContextMenuEvent *result = 0 ;
29201 int val1 ;
29202 int ecode1 = 0 ;
29203 int val2 ;
29204 int ecode2 = 0 ;
29205 wxPoint temp3 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 PyObject * obj2 = 0 ;
29209 char * kwnames[] = {
29210 (char *) "type",(char *) "winid",(char *) "pt", NULL
29211 };
29212
29213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29214 if (obj0) {
29215 ecode1 = SWIG_AsVal_int(obj0, &val1);
29216 if (!SWIG_IsOK(ecode1)) {
29217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29218 }
29219 arg1 = static_cast< wxEventType >(val1);
29220 }
29221 if (obj1) {
29222 ecode2 = SWIG_AsVal_int(obj1, &val2);
29223 if (!SWIG_IsOK(ecode2)) {
29224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29225 }
29226 arg2 = static_cast< int >(val2);
29227 }
29228 if (obj2) {
29229 {
29230 arg3 = &temp3;
29231 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29232 }
29233 }
29234 {
29235 PyThreadState* __tstate = wxPyBeginAllowThreads();
29236 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29248 PyObject *resultobj = 0;
29249 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29250 wxPoint *result = 0 ;
29251 void *argp1 = 0 ;
29252 int res1 = 0 ;
29253 PyObject *swig_obj[1] ;
29254
29255 if (!args) SWIG_fail;
29256 swig_obj[0] = args;
29257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29258 if (!SWIG_IsOK(res1)) {
29259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29260 }
29261 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 {
29265 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29266 result = (wxPoint *) &_result_ref;
29267 }
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj = 0;
29280 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29281 wxPoint *arg2 = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 wxPoint temp2 ;
29285 PyObject * obj0 = 0 ;
29286 PyObject * obj1 = 0 ;
29287 char * kwnames[] = {
29288 (char *) "self",(char *) "pos", NULL
29289 };
29290
29291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29293 if (!SWIG_IsOK(res1)) {
29294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29295 }
29296 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29297 {
29298 arg2 = &temp2;
29299 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29300 }
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 (arg1)->SetPosition((wxPoint const &)*arg2);
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 resultobj = SWIG_Py_Void();
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29315 PyObject *obj;
29316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29317 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29318 return SWIG_Py_Void();
29319 }
29320
29321 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29322 return SWIG_Python_InitShadowInstance(args);
29323 }
29324
29325 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29326 PyObject *resultobj = 0;
29327 wxIdleEvent *result = 0 ;
29328
29329 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = (wxIdleEvent *)new wxIdleEvent();
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj = 0;
29345 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29346 bool arg2 = (bool) true ;
29347 void *argp1 = 0 ;
29348 int res1 = 0 ;
29349 bool val2 ;
29350 int ecode2 = 0 ;
29351 PyObject * obj0 = 0 ;
29352 PyObject * obj1 = 0 ;
29353 char * kwnames[] = {
29354 (char *) "self",(char *) "needMore", NULL
29355 };
29356
29357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29359 if (!SWIG_IsOK(res1)) {
29360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29361 }
29362 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29363 if (obj1) {
29364 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29365 if (!SWIG_IsOK(ecode2)) {
29366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29367 }
29368 arg2 = static_cast< bool >(val2);
29369 }
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 (arg1)->RequestMore(arg2);
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_Py_Void();
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 PyObject *resultobj = 0;
29385 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29386 bool result;
29387 void *argp1 = 0 ;
29388 int res1 = 0 ;
29389 PyObject *swig_obj[1] ;
29390
29391 if (!args) SWIG_fail;
29392 swig_obj[0] = args;
29393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29396 }
29397 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 {
29405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29406 }
29407 return resultobj;
29408 fail:
29409 return NULL;
29410 }
29411
29412
29413 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29414 PyObject *resultobj = 0;
29415 wxIdleMode arg1 ;
29416 int val1 ;
29417 int ecode1 = 0 ;
29418 PyObject * obj0 = 0 ;
29419 char * kwnames[] = {
29420 (char *) "mode", NULL
29421 };
29422
29423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29424 ecode1 = SWIG_AsVal_int(obj0, &val1);
29425 if (!SWIG_IsOK(ecode1)) {
29426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29427 }
29428 arg1 = static_cast< wxIdleMode >(val1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 wxIdleEvent::SetMode(arg1);
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 resultobj = SWIG_Py_Void();
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29443 PyObject *resultobj = 0;
29444 wxIdleMode result;
29445
29446 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (wxIdleMode)wxIdleEvent::GetMode();
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 resultobj = SWIG_From_int(static_cast< int >(result));
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj = 0;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 bool result;
29464 void *argp1 = 0 ;
29465 int res1 = 0 ;
29466 PyObject * obj0 = 0 ;
29467 char * kwnames[] = {
29468 (char *) "win", NULL
29469 };
29470
29471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29473 if (!SWIG_IsOK(res1)) {
29474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29475 }
29476 arg1 = reinterpret_cast< wxWindow * >(argp1);
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (bool)wxIdleEvent::CanSend(arg1);
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29485 }
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29493 PyObject *obj;
29494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29495 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29496 return SWIG_Py_Void();
29497 }
29498
29499 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29500 return SWIG_Python_InitShadowInstance(args);
29501 }
29502
29503 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29504 PyObject *resultobj = 0;
29505 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29506 int arg2 = (int) 0 ;
29507 wxClipboardTextEvent *result = 0 ;
29508 int val1 ;
29509 int ecode1 = 0 ;
29510 int val2 ;
29511 int ecode2 = 0 ;
29512 PyObject * obj0 = 0 ;
29513 PyObject * obj1 = 0 ;
29514 char * kwnames[] = {
29515 (char *) "type",(char *) "winid", NULL
29516 };
29517
29518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29519 if (obj0) {
29520 ecode1 = SWIG_AsVal_int(obj0, &val1);
29521 if (!SWIG_IsOK(ecode1)) {
29522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29523 }
29524 arg1 = static_cast< wxEventType >(val1);
29525 }
29526 if (obj1) {
29527 ecode2 = SWIG_AsVal_int(obj1, &val2);
29528 if (!SWIG_IsOK(ecode2)) {
29529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29530 }
29531 arg2 = static_cast< int >(val2);
29532 }
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29536 wxPyEndAllowThreads(__tstate);
29537 if (PyErr_Occurred()) SWIG_fail;
29538 }
29539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29540 return resultobj;
29541 fail:
29542 return NULL;
29543 }
29544
29545
29546 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29547 PyObject *obj;
29548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29549 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29550 return SWIG_Py_Void();
29551 }
29552
29553 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29554 return SWIG_Python_InitShadowInstance(args);
29555 }
29556
29557 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29558 PyObject *resultobj = 0;
29559 int arg1 = (int) 0 ;
29560 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29561 wxPyEvent *result = 0 ;
29562 int val1 ;
29563 int ecode1 = 0 ;
29564 int val2 ;
29565 int ecode2 = 0 ;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 char * kwnames[] = {
29569 (char *) "winid",(char *) "eventType", NULL
29570 };
29571
29572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29573 if (obj0) {
29574 ecode1 = SWIG_AsVal_int(obj0, &val1);
29575 if (!SWIG_IsOK(ecode1)) {
29576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29577 }
29578 arg1 = static_cast< int >(val1);
29579 }
29580 if (obj1) {
29581 ecode2 = SWIG_AsVal_int(obj1, &val2);
29582 if (!SWIG_IsOK(ecode2)) {
29583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29584 }
29585 arg2 = static_cast< wxEventType >(val2);
29586 }
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29601 PyObject *resultobj = 0;
29602 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29612 }
29613 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 delete arg1;
29617
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 resultobj = SWIG_Py_Void();
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj = 0;
29630 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29631 PyObject *arg2 = (PyObject *) 0 ;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 PyObject * obj0 = 0 ;
29635 PyObject * obj1 = 0 ;
29636 char * kwnames[] = {
29637 (char *) "self",(char *) "self", NULL
29638 };
29639
29640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29642 if (!SWIG_IsOK(res1)) {
29643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29644 }
29645 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29646 arg2 = obj1;
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 (arg1)->SetSelf(arg2);
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_Py_Void();
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29661 PyObject *resultobj = 0;
29662 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29663 PyObject *result = 0 ;
29664 void *argp1 = 0 ;
29665 int res1 = 0 ;
29666 PyObject *swig_obj[1] ;
29667
29668 if (!args) SWIG_fail;
29669 swig_obj[0] = args;
29670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29671 if (!SWIG_IsOK(res1)) {
29672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29673 }
29674 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 result = (PyObject *)(arg1)->GetSelf();
29678 wxPyEndAllowThreads(__tstate);
29679 if (PyErr_Occurred()) SWIG_fail;
29680 }
29681 resultobj = result;
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29689 PyObject *obj;
29690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29691 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29692 return SWIG_Py_Void();
29693 }
29694
29695 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29696 return SWIG_Python_InitShadowInstance(args);
29697 }
29698
29699 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29700 PyObject *resultobj = 0;
29701 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29702 int arg2 = (int) 0 ;
29703 wxPyCommandEvent *result = 0 ;
29704 int val1 ;
29705 int ecode1 = 0 ;
29706 int val2 ;
29707 int ecode2 = 0 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 char * kwnames[] = {
29711 (char *) "eventType",(char *) "id", NULL
29712 };
29713
29714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29715 if (obj0) {
29716 ecode1 = SWIG_AsVal_int(obj0, &val1);
29717 if (!SWIG_IsOK(ecode1)) {
29718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29719 }
29720 arg1 = static_cast< wxEventType >(val1);
29721 }
29722 if (obj1) {
29723 ecode2 = SWIG_AsVal_int(obj1, &val2);
29724 if (!SWIG_IsOK(ecode2)) {
29725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29726 }
29727 arg2 = static_cast< int >(val2);
29728 }
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29743 PyObject *resultobj = 0;
29744 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29745 void *argp1 = 0 ;
29746 int res1 = 0 ;
29747 PyObject *swig_obj[1] ;
29748
29749 if (!args) SWIG_fail;
29750 swig_obj[0] = args;
29751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29752 if (!SWIG_IsOK(res1)) {
29753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29754 }
29755 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 delete arg1;
29759
29760 wxPyEndAllowThreads(__tstate);
29761 if (PyErr_Occurred()) SWIG_fail;
29762 }
29763 resultobj = SWIG_Py_Void();
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29771 PyObject *resultobj = 0;
29772 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29773 PyObject *arg2 = (PyObject *) 0 ;
29774 void *argp1 = 0 ;
29775 int res1 = 0 ;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 char * kwnames[] = {
29779 (char *) "self",(char *) "self", NULL
29780 };
29781
29782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29784 if (!SWIG_IsOK(res1)) {
29785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29786 }
29787 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29788 arg2 = obj1;
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 (arg1)->SetSelf(arg2);
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_Py_Void();
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29803 PyObject *resultobj = 0;
29804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29805 PyObject *result = 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 PyObject *swig_obj[1] ;
29809
29810 if (!args) SWIG_fail;
29811 swig_obj[0] = args;
29812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29813 if (!SWIG_IsOK(res1)) {
29814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29815 }
29816 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 result = (PyObject *)(arg1)->GetSelf();
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 resultobj = result;
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29831 PyObject *obj;
29832 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29833 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29834 return SWIG_Py_Void();
29835 }
29836
29837 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29838 return SWIG_Python_InitShadowInstance(args);
29839 }
29840
29841 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29842 PyObject *resultobj = 0;
29843 wxWindow *arg1 = (wxWindow *) 0 ;
29844 wxDateTime *arg2 = 0 ;
29845 wxEventType arg3 ;
29846 wxDateEvent *result = 0 ;
29847 void *argp1 = 0 ;
29848 int res1 = 0 ;
29849 void *argp2 = 0 ;
29850 int res2 = 0 ;
29851 int val3 ;
29852 int ecode3 = 0 ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 PyObject * obj2 = 0 ;
29856 char * kwnames[] = {
29857 (char *) "win",(char *) "dt",(char *) "type", NULL
29858 };
29859
29860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29862 if (!SWIG_IsOK(res1)) {
29863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29864 }
29865 arg1 = reinterpret_cast< wxWindow * >(argp1);
29866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29867 if (!SWIG_IsOK(res2)) {
29868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29869 }
29870 if (!argp2) {
29871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29872 }
29873 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29874 ecode3 = SWIG_AsVal_int(obj2, &val3);
29875 if (!SWIG_IsOK(ecode3)) {
29876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29877 }
29878 arg3 = static_cast< wxEventType >(val3);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29895 wxDateTime *result = 0 ;
29896 void *argp1 = 0 ;
29897 int res1 = 0 ;
29898 PyObject *swig_obj[1] ;
29899
29900 if (!args) SWIG_fail;
29901 swig_obj[0] = args;
29902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29905 }
29906 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29907 {
29908 PyThreadState* __tstate = wxPyBeginAllowThreads();
29909 {
29910 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29911 result = (wxDateTime *) &_result_ref;
29912 }
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj = 0;
29925 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29926 wxDateTime *arg2 = 0 ;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 void *argp2 = 0 ;
29930 int res2 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 PyObject * obj1 = 0 ;
29933 char * kwnames[] = {
29934 (char *) "self",(char *) "date", NULL
29935 };
29936
29937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29939 if (!SWIG_IsOK(res1)) {
29940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29941 }
29942 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29944 if (!SWIG_IsOK(res2)) {
29945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29946 }
29947 if (!argp2) {
29948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29949 }
29950 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 (arg1)->SetDate((wxDateTime const &)*arg2);
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 resultobj = SWIG_Py_Void();
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29965 PyObject *obj;
29966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29967 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29968 return SWIG_Py_Void();
29969 }
29970
29971 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29972 return SWIG_Python_InitShadowInstance(args);
29973 }
29974
29975 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29976 PyObject *resultobj = 0;
29977 wxPyApp *result = 0 ;
29978
29979 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29980 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 result = (wxPyApp *)new_wxPyApp();
29983 wxPyEndAllowThreads(__tstate);
29984 if (PyErr_Occurred()) SWIG_fail;
29985 }
29986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29987 return resultobj;
29988 fail:
29989 return NULL;
29990 }
29991
29992
29993 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29994 PyObject *resultobj = 0;
29995 wxPyApp *arg1 = (wxPyApp *) 0 ;
29996 void *argp1 = 0 ;
29997 int res1 = 0 ;
29998 PyObject *swig_obj[1] ;
29999
30000 if (!args) SWIG_fail;
30001 swig_obj[0] = args;
30002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30005 }
30006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 delete arg1;
30010
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_Py_Void();
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = 0;
30023 wxPyApp *arg1 = (wxPyApp *) 0 ;
30024 PyObject *arg2 = (PyObject *) 0 ;
30025 PyObject *arg3 = (PyObject *) 0 ;
30026 bool arg4 ;
30027 void *argp1 = 0 ;
30028 int res1 = 0 ;
30029 bool val4 ;
30030 int ecode4 = 0 ;
30031 PyObject * obj0 = 0 ;
30032 PyObject * obj1 = 0 ;
30033 PyObject * obj2 = 0 ;
30034 PyObject * obj3 = 0 ;
30035 char * kwnames[] = {
30036 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30037 };
30038
30039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30041 if (!SWIG_IsOK(res1)) {
30042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30043 }
30044 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30045 arg2 = obj1;
30046 arg3 = obj2;
30047 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30048 if (!SWIG_IsOK(ecode4)) {
30049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30050 }
30051 arg4 = static_cast< bool >(val4);
30052 {
30053 PyThreadState* __tstate = wxPyBeginAllowThreads();
30054 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 resultobj = SWIG_Py_Void();
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30066 PyObject *resultobj = 0;
30067 wxPyApp *arg1 = (wxPyApp *) 0 ;
30068 wxString result;
30069 void *argp1 = 0 ;
30070 int res1 = 0 ;
30071 PyObject *swig_obj[1] ;
30072
30073 if (!args) SWIG_fail;
30074 swig_obj[0] = args;
30075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30078 }
30079 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = ((wxPyApp const *)arg1)->GetAppName();
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 {
30087 #if wxUSE_UNICODE
30088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30089 #else
30090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30091 #endif
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj = 0;
30101 wxPyApp *arg1 = (wxPyApp *) 0 ;
30102 wxString *arg2 = 0 ;
30103 void *argp1 = 0 ;
30104 int res1 = 0 ;
30105 bool temp2 = false ;
30106 PyObject * obj0 = 0 ;
30107 PyObject * obj1 = 0 ;
30108 char * kwnames[] = {
30109 (char *) "self",(char *) "name", NULL
30110 };
30111
30112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30114 if (!SWIG_IsOK(res1)) {
30115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30116 }
30117 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30118 {
30119 arg2 = wxString_in_helper(obj1);
30120 if (arg2 == NULL) SWIG_fail;
30121 temp2 = true;
30122 }
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 (arg1)->SetAppName((wxString const &)*arg2);
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 resultobj = SWIG_Py_Void();
30130 {
30131 if (temp2)
30132 delete arg2;
30133 }
30134 return resultobj;
30135 fail:
30136 {
30137 if (temp2)
30138 delete arg2;
30139 }
30140 return NULL;
30141 }
30142
30143
30144 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30145 PyObject *resultobj = 0;
30146 wxPyApp *arg1 = (wxPyApp *) 0 ;
30147 wxString result;
30148 void *argp1 = 0 ;
30149 int res1 = 0 ;
30150 PyObject *swig_obj[1] ;
30151
30152 if (!args) SWIG_fail;
30153 swig_obj[0] = args;
30154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30155 if (!SWIG_IsOK(res1)) {
30156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30157 }
30158 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = ((wxPyApp const *)arg1)->GetClassName();
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 {
30166 #if wxUSE_UNICODE
30167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30168 #else
30169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30170 #endif
30171 }
30172 return resultobj;
30173 fail:
30174 return NULL;
30175 }
30176
30177
30178 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30179 PyObject *resultobj = 0;
30180 wxPyApp *arg1 = (wxPyApp *) 0 ;
30181 wxString *arg2 = 0 ;
30182 void *argp1 = 0 ;
30183 int res1 = 0 ;
30184 bool temp2 = false ;
30185 PyObject * obj0 = 0 ;
30186 PyObject * obj1 = 0 ;
30187 char * kwnames[] = {
30188 (char *) "self",(char *) "name", NULL
30189 };
30190
30191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30193 if (!SWIG_IsOK(res1)) {
30194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30195 }
30196 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30197 {
30198 arg2 = wxString_in_helper(obj1);
30199 if (arg2 == NULL) SWIG_fail;
30200 temp2 = true;
30201 }
30202 {
30203 PyThreadState* __tstate = wxPyBeginAllowThreads();
30204 (arg1)->SetClassName((wxString const &)*arg2);
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 resultobj = SWIG_Py_Void();
30209 {
30210 if (temp2)
30211 delete arg2;
30212 }
30213 return resultobj;
30214 fail:
30215 {
30216 if (temp2)
30217 delete arg2;
30218 }
30219 return NULL;
30220 }
30221
30222
30223 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30224 PyObject *resultobj = 0;
30225 wxPyApp *arg1 = (wxPyApp *) 0 ;
30226 wxString *result = 0 ;
30227 void *argp1 = 0 ;
30228 int res1 = 0 ;
30229 PyObject *swig_obj[1] ;
30230
30231 if (!args) SWIG_fail;
30232 swig_obj[0] = args;
30233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30234 if (!SWIG_IsOK(res1)) {
30235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30236 }
30237 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 {
30241 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30242 result = (wxString *) &_result_ref;
30243 }
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 {
30248 #if wxUSE_UNICODE
30249 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30250 #else
30251 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30252 #endif
30253 }
30254 return resultobj;
30255 fail:
30256 return NULL;
30257 }
30258
30259
30260 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30261 PyObject *resultobj = 0;
30262 wxPyApp *arg1 = (wxPyApp *) 0 ;
30263 wxString *arg2 = 0 ;
30264 void *argp1 = 0 ;
30265 int res1 = 0 ;
30266 bool temp2 = false ;
30267 PyObject * obj0 = 0 ;
30268 PyObject * obj1 = 0 ;
30269 char * kwnames[] = {
30270 (char *) "self",(char *) "name", NULL
30271 };
30272
30273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30277 }
30278 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30279 {
30280 arg2 = wxString_in_helper(obj1);
30281 if (arg2 == NULL) SWIG_fail;
30282 temp2 = true;
30283 }
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 (arg1)->SetVendorName((wxString const &)*arg2);
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 resultobj = SWIG_Py_Void();
30291 {
30292 if (temp2)
30293 delete arg2;
30294 }
30295 return resultobj;
30296 fail:
30297 {
30298 if (temp2)
30299 delete arg2;
30300 }
30301 return NULL;
30302 }
30303
30304
30305 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30306 PyObject *resultobj = 0;
30307 wxPyApp *arg1 = (wxPyApp *) 0 ;
30308 wxAppTraits *result = 0 ;
30309 void *argp1 = 0 ;
30310 int res1 = 0 ;
30311 PyObject *swig_obj[1] ;
30312
30313 if (!args) SWIG_fail;
30314 swig_obj[0] = args;
30315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30316 if (!SWIG_IsOK(res1)) {
30317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30318 }
30319 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 result = (wxAppTraits *)(arg1)->GetTraits();
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30334 PyObject *resultobj = 0;
30335 wxPyApp *arg1 = (wxPyApp *) 0 ;
30336 void *argp1 = 0 ;
30337 int res1 = 0 ;
30338 PyObject *swig_obj[1] ;
30339
30340 if (!args) SWIG_fail;
30341 swig_obj[0] = args;
30342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30345 }
30346 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 (arg1)->ProcessPendingEvents();
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 resultobj = SWIG_Py_Void();
30354 return resultobj;
30355 fail:
30356 return NULL;
30357 }
30358
30359
30360 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30361 PyObject *resultobj = 0;
30362 wxPyApp *arg1 = (wxPyApp *) 0 ;
30363 bool arg2 = (bool) false ;
30364 bool result;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 bool val2 ;
30368 int ecode2 = 0 ;
30369 PyObject * obj0 = 0 ;
30370 PyObject * obj1 = 0 ;
30371 char * kwnames[] = {
30372 (char *) "self",(char *) "onlyIfNeeded", NULL
30373 };
30374
30375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30377 if (!SWIG_IsOK(res1)) {
30378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30379 }
30380 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30381 if (obj1) {
30382 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30383 if (!SWIG_IsOK(ecode2)) {
30384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30385 }
30386 arg2 = static_cast< bool >(val2);
30387 }
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 result = (bool)(arg1)->Yield(arg2);
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 {
30395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30404 PyObject *resultobj = 0;
30405 wxPyApp *arg1 = (wxPyApp *) 0 ;
30406 void *argp1 = 0 ;
30407 int res1 = 0 ;
30408 PyObject *swig_obj[1] ;
30409
30410 if (!args) SWIG_fail;
30411 swig_obj[0] = args;
30412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30413 if (!SWIG_IsOK(res1)) {
30414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30415 }
30416 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 (arg1)->WakeUpIdle();
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 resultobj = SWIG_Py_Void();
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30431 PyObject *resultobj = 0;
30432 bool result;
30433
30434 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (bool)wxPyApp::IsMainLoopRunning();
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 {
30442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30443 }
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxPyApp *arg1 = (wxPyApp *) 0 ;
30453 int result;
30454 void *argp1 = 0 ;
30455 int res1 = 0 ;
30456 PyObject *swig_obj[1] ;
30457
30458 if (!args) SWIG_fail;
30459 swig_obj[0] = args;
30460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30463 }
30464 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 result = (int)(arg1)->MainLoop();
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 resultobj = SWIG_From_int(static_cast< int >(result));
30472 return resultobj;
30473 fail:
30474 return NULL;
30475 }
30476
30477
30478 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30479 PyObject *resultobj = 0;
30480 wxPyApp *arg1 = (wxPyApp *) 0 ;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 PyObject *swig_obj[1] ;
30484
30485 if (!args) SWIG_fail;
30486 swig_obj[0] = args;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30490 }
30491 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 (arg1)->Exit();
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 resultobj = SWIG_Py_Void();
30499 return resultobj;
30500 fail:
30501 return NULL;
30502 }
30503
30504
30505 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30506 PyObject *resultobj = 0;
30507 wxPyApp *arg1 = (wxPyApp *) 0 ;
30508 wxLayoutDirection result;
30509 void *argp1 = 0 ;
30510 int res1 = 0 ;
30511 PyObject *swig_obj[1] ;
30512
30513 if (!args) SWIG_fail;
30514 swig_obj[0] = args;
30515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30516 if (!SWIG_IsOK(res1)) {
30517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30518 }
30519 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_From_int(static_cast< int >(result));
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30534 PyObject *resultobj = 0;
30535 wxPyApp *arg1 = (wxPyApp *) 0 ;
30536 void *argp1 = 0 ;
30537 int res1 = 0 ;
30538 PyObject *swig_obj[1] ;
30539
30540 if (!args) SWIG_fail;
30541 swig_obj[0] = args;
30542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30543 if (!SWIG_IsOK(res1)) {
30544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30545 }
30546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 (arg1)->ExitMainLoop();
30550 wxPyEndAllowThreads(__tstate);
30551 if (PyErr_Occurred()) SWIG_fail;
30552 }
30553 resultobj = SWIG_Py_Void();
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30561 PyObject *resultobj = 0;
30562 wxPyApp *arg1 = (wxPyApp *) 0 ;
30563 bool result;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 PyObject *swig_obj[1] ;
30567
30568 if (!args) SWIG_fail;
30569 swig_obj[0] = args;
30570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30571 if (!SWIG_IsOK(res1)) {
30572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30573 }
30574 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30575 {
30576 PyThreadState* __tstate = wxPyBeginAllowThreads();
30577 result = (bool)(arg1)->Pending();
30578 wxPyEndAllowThreads(__tstate);
30579 if (PyErr_Occurred()) SWIG_fail;
30580 }
30581 {
30582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30583 }
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30591 PyObject *resultobj = 0;
30592 wxPyApp *arg1 = (wxPyApp *) 0 ;
30593 bool result;
30594 void *argp1 = 0 ;
30595 int res1 = 0 ;
30596 PyObject *swig_obj[1] ;
30597
30598 if (!args) SWIG_fail;
30599 swig_obj[0] = args;
30600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30601 if (!SWIG_IsOK(res1)) {
30602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30603 }
30604 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 result = (bool)(arg1)->Dispatch();
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 {
30612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30613 }
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30621 PyObject *resultobj = 0;
30622 wxPyApp *arg1 = (wxPyApp *) 0 ;
30623 bool result;
30624 void *argp1 = 0 ;
30625 int res1 = 0 ;
30626 PyObject *swig_obj[1] ;
30627
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30633 }
30634 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (bool)(arg1)->ProcessIdle();
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 {
30642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30643 }
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj = 0;
30652 wxPyApp *arg1 = (wxPyApp *) 0 ;
30653 wxWindow *arg2 = (wxWindow *) 0 ;
30654 wxIdleEvent *arg3 = 0 ;
30655 bool result;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 void *argp2 = 0 ;
30659 int res2 = 0 ;
30660 void *argp3 = 0 ;
30661 int res3 = 0 ;
30662 PyObject * obj0 = 0 ;
30663 PyObject * obj1 = 0 ;
30664 PyObject * obj2 = 0 ;
30665 char * kwnames[] = {
30666 (char *) "self",(char *) "win",(char *) "event", NULL
30667 };
30668
30669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30673 }
30674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30676 if (!SWIG_IsOK(res2)) {
30677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30678 }
30679 arg2 = reinterpret_cast< wxWindow * >(argp2);
30680 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30681 if (!SWIG_IsOK(res3)) {
30682 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30683 }
30684 if (!argp3) {
30685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30686 }
30687 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30688 {
30689 PyThreadState* __tstate = wxPyBeginAllowThreads();
30690 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30691 wxPyEndAllowThreads(__tstate);
30692 if (PyErr_Occurred()) SWIG_fail;
30693 }
30694 {
30695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30696 }
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 PyObject *resultobj = 0;
30705 wxPyApp *arg1 = (wxPyApp *) 0 ;
30706 bool result;
30707 void *argp1 = 0 ;
30708 int res1 = 0 ;
30709 PyObject *swig_obj[1] ;
30710
30711 if (!args) SWIG_fail;
30712 swig_obj[0] = args;
30713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30714 if (!SWIG_IsOK(res1)) {
30715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30716 }
30717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 result = (bool)((wxPyApp const *)arg1)->IsActive();
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 {
30725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxPyApp *arg1 = (wxPyApp *) 0 ;
30736 wxWindow *arg2 = (wxWindow *) 0 ;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 void *argp2 = 0 ;
30740 int res2 = 0 ;
30741 PyObject * obj0 = 0 ;
30742 PyObject * obj1 = 0 ;
30743 char * kwnames[] = {
30744 (char *) "self",(char *) "win", NULL
30745 };
30746
30747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30751 }
30752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30754 if (!SWIG_IsOK(res2)) {
30755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30756 }
30757 arg2 = reinterpret_cast< wxWindow * >(argp2);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 (arg1)->SetTopWindow(arg2);
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_Py_Void();
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxPyApp *arg1 = (wxPyApp *) 0 ;
30774 wxWindow *result = 0 ;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30784 }
30785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = wxPyMake_wxObject(result, (bool)0);
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj = 0;
30803 wxPyApp *arg1 = (wxPyApp *) 0 ;
30804 bool arg2 ;
30805 void *argp1 = 0 ;
30806 int res1 = 0 ;
30807 bool val2 ;
30808 int ecode2 = 0 ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 char * kwnames[] = {
30812 (char *) "self",(char *) "flag", NULL
30813 };
30814
30815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30819 }
30820 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30822 if (!SWIG_IsOK(ecode2)) {
30823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30824 }
30825 arg2 = static_cast< bool >(val2);
30826 {
30827 PyThreadState* __tstate = wxPyBeginAllowThreads();
30828 (arg1)->SetExitOnFrameDelete(arg2);
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 resultobj = SWIG_Py_Void();
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxPyApp *arg1 = (wxPyApp *) 0 ;
30842 bool result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj = 0;
30871 wxPyApp *arg1 = (wxPyApp *) 0 ;
30872 bool arg2 ;
30873 void *argp1 = 0 ;
30874 int res1 = 0 ;
30875 bool val2 ;
30876 int ecode2 = 0 ;
30877 PyObject * obj0 = 0 ;
30878 PyObject * obj1 = 0 ;
30879 char * kwnames[] = {
30880 (char *) "self",(char *) "flag", NULL
30881 };
30882
30883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30885 if (!SWIG_IsOK(res1)) {
30886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30887 }
30888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30890 if (!SWIG_IsOK(ecode2)) {
30891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30892 }
30893 arg2 = static_cast< bool >(val2);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 (arg1)->SetUseBestVisual(arg2);
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 resultobj = SWIG_Py_Void();
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30908 PyObject *resultobj = 0;
30909 wxPyApp *arg1 = (wxPyApp *) 0 ;
30910 bool result;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 PyObject *swig_obj[1] ;
30914
30915 if (!args) SWIG_fail;
30916 swig_obj[0] = args;
30917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30920 }
30921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj = 0;
30939 wxPyApp *arg1 = (wxPyApp *) 0 ;
30940 int arg2 ;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 int val2 ;
30944 int ecode2 = 0 ;
30945 PyObject * obj0 = 0 ;
30946 PyObject * obj1 = 0 ;
30947 char * kwnames[] = {
30948 (char *) "self",(char *) "mode", NULL
30949 };
30950
30951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30955 }
30956 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30957 ecode2 = SWIG_AsVal_int(obj1, &val2);
30958 if (!SWIG_IsOK(ecode2)) {
30959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30960 }
30961 arg2 = static_cast< int >(val2);
30962 {
30963 PyThreadState* __tstate = wxPyBeginAllowThreads();
30964 (arg1)->SetPrintMode(arg2);
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 resultobj = SWIG_Py_Void();
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30976 PyObject *resultobj = 0;
30977 wxPyApp *arg1 = (wxPyApp *) 0 ;
30978 int result;
30979 void *argp1 = 0 ;
30980 int res1 = 0 ;
30981 PyObject *swig_obj[1] ;
30982
30983 if (!args) SWIG_fail;
30984 swig_obj[0] = args;
30985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30988 }
30989 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30993 wxPyEndAllowThreads(__tstate);
30994 if (PyErr_Occurred()) SWIG_fail;
30995 }
30996 resultobj = SWIG_From_int(static_cast< int >(result));
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj = 0;
31005 wxPyApp *arg1 = (wxPyApp *) 0 ;
31006 int arg2 ;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 int val2 ;
31010 int ecode2 = 0 ;
31011 PyObject * obj0 = 0 ;
31012 PyObject * obj1 = 0 ;
31013 char * kwnames[] = {
31014 (char *) "self",(char *) "mode", NULL
31015 };
31016
31017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31019 if (!SWIG_IsOK(res1)) {
31020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31021 }
31022 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31023 ecode2 = SWIG_AsVal_int(obj1, &val2);
31024 if (!SWIG_IsOK(ecode2)) {
31025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31026 }
31027 arg2 = static_cast< int >(val2);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 (arg1)->SetAssertMode(arg2);
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_Py_Void();
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 wxPyApp *arg1 = (wxPyApp *) 0 ;
31044 int result;
31045 void *argp1 = 0 ;
31046 int res1 = 0 ;
31047 PyObject *swig_obj[1] ;
31048
31049 if (!args) SWIG_fail;
31050 swig_obj[0] = args;
31051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31054 }
31055 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 result = (int)(arg1)->GetAssertMode();
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_From_int(static_cast< int >(result));
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 bool result;
31072
31073 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31074 {
31075 PyThreadState* __tstate = wxPyBeginAllowThreads();
31076 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 {
31081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31082 }
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 long result;
31092
31093 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = (long)wxPyApp::GetMacAboutMenuItemId();
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 resultobj = SWIG_From_long(static_cast< long >(result));
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31108 PyObject *resultobj = 0;
31109 long result;
31110
31111 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 resultobj = SWIG_From_long(static_cast< long >(result));
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31126 PyObject *resultobj = 0;
31127 long result;
31128
31129 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = (long)wxPyApp::GetMacExitMenuItemId();
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 resultobj = SWIG_From_long(static_cast< long >(result));
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31144 PyObject *resultobj = 0;
31145 wxString result;
31146
31147 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = wxPyApp::GetMacHelpMenuTitleName();
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 #if wxUSE_UNICODE
31156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31157 #else
31158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31159 #endif
31160 }
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31168 PyObject *resultobj = 0;
31169 bool arg1 ;
31170 bool val1 ;
31171 int ecode1 = 0 ;
31172 PyObject * obj0 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "val", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31178 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31179 if (!SWIG_IsOK(ecode1)) {
31180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31181 }
31182 arg1 = static_cast< bool >(val1);
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_Py_Void();
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = 0;
31198 long arg1 ;
31199 long val1 ;
31200 int ecode1 = 0 ;
31201 PyObject * obj0 = 0 ;
31202 char * kwnames[] = {
31203 (char *) "val", NULL
31204 };
31205
31206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31207 ecode1 = SWIG_AsVal_long(obj0, &val1);
31208 if (!SWIG_IsOK(ecode1)) {
31209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31210 }
31211 arg1 = static_cast< long >(val1);
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 wxPyApp::SetMacAboutMenuItemId(arg1);
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 resultobj = SWIG_Py_Void();
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31226 PyObject *resultobj = 0;
31227 long arg1 ;
31228 long val1 ;
31229 int ecode1 = 0 ;
31230 PyObject * obj0 = 0 ;
31231 char * kwnames[] = {
31232 (char *) "val", NULL
31233 };
31234
31235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31236 ecode1 = SWIG_AsVal_long(obj0, &val1);
31237 if (!SWIG_IsOK(ecode1)) {
31238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31239 }
31240 arg1 = static_cast< long >(val1);
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_Py_Void();
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31255 PyObject *resultobj = 0;
31256 long arg1 ;
31257 long val1 ;
31258 int ecode1 = 0 ;
31259 PyObject * obj0 = 0 ;
31260 char * kwnames[] = {
31261 (char *) "val", NULL
31262 };
31263
31264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31265 ecode1 = SWIG_AsVal_long(obj0, &val1);
31266 if (!SWIG_IsOK(ecode1)) {
31267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31268 }
31269 arg1 = static_cast< long >(val1);
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 wxPyApp::SetMacExitMenuItemId(arg1);
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 resultobj = SWIG_Py_Void();
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj = 0;
31285 wxString *arg1 = 0 ;
31286 bool temp1 = false ;
31287 PyObject * obj0 = 0 ;
31288 char * kwnames[] = {
31289 (char *) "val", NULL
31290 };
31291
31292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31293 {
31294 arg1 = wxString_in_helper(obj0);
31295 if (arg1 == NULL) SWIG_fail;
31296 temp1 = true;
31297 }
31298 {
31299 PyThreadState* __tstate = wxPyBeginAllowThreads();
31300 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 resultobj = SWIG_Py_Void();
31305 {
31306 if (temp1)
31307 delete arg1;
31308 }
31309 return resultobj;
31310 fail:
31311 {
31312 if (temp1)
31313 delete arg1;
31314 }
31315 return NULL;
31316 }
31317
31318
31319 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 PyObject *resultobj = 0;
31321 wxPyApp *arg1 = (wxPyApp *) 0 ;
31322 void *argp1 = 0 ;
31323 int res1 = 0 ;
31324 PyObject *swig_obj[1] ;
31325
31326 if (!args) SWIG_fail;
31327 swig_obj[0] = args;
31328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31331 }
31332 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 (arg1)->_BootstrapApp();
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_Py_Void();
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31347 PyObject *resultobj = 0;
31348 int result;
31349
31350 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31351 {
31352 PyThreadState* __tstate = wxPyBeginAllowThreads();
31353 result = (int)wxPyApp_GetComCtl32Version();
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 resultobj = SWIG_From_int(static_cast< int >(result));
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31365 PyObject *resultobj = 0;
31366 bool result;
31367
31368 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31369 {
31370 PyThreadState* __tstate = wxPyBeginAllowThreads();
31371 result = (bool)wxPyApp_IsDisplayAvailable();
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 {
31376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31377 }
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31385 PyObject *obj;
31386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31387 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31388 return SWIG_Py_Void();
31389 }
31390
31391 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31392 return SWIG_Python_InitShadowInstance(args);
31393 }
31394
31395 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31396 PyObject *resultobj = 0;
31397
31398 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 wxExit();
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_Py_Void();
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31413 PyObject *resultobj = 0;
31414 bool result;
31415
31416 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 result = (bool)wxYield();
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 {
31424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433 PyObject *resultobj = 0;
31434 bool result;
31435
31436 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 result = (bool)wxYieldIfNeeded();
31440 wxPyEndAllowThreads(__tstate);
31441 if (PyErr_Occurred()) SWIG_fail;
31442 }
31443 {
31444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31445 }
31446 return resultobj;
31447 fail:
31448 return NULL;
31449 }
31450
31451
31452 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31453 PyObject *resultobj = 0;
31454 wxWindow *arg1 = (wxWindow *) NULL ;
31455 bool arg2 = (bool) false ;
31456 bool result;
31457 void *argp1 = 0 ;
31458 int res1 = 0 ;
31459 bool val2 ;
31460 int ecode2 = 0 ;
31461 PyObject * obj0 = 0 ;
31462 PyObject * obj1 = 0 ;
31463 char * kwnames[] = {
31464 (char *) "win",(char *) "onlyIfNeeded", NULL
31465 };
31466
31467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31468 if (obj0) {
31469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31470 if (!SWIG_IsOK(res1)) {
31471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31472 }
31473 arg1 = reinterpret_cast< wxWindow * >(argp1);
31474 }
31475 if (obj1) {
31476 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31477 if (!SWIG_IsOK(ecode2)) {
31478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31479 }
31480 arg2 = static_cast< bool >(val2);
31481 }
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 result = (bool)wxSafeYield(arg1,arg2);
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 {
31489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31490 }
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31498 PyObject *resultobj = 0;
31499
31500 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31501 {
31502 PyThreadState* __tstate = wxPyBeginAllowThreads();
31503 wxWakeUpIdle();
31504 wxPyEndAllowThreads(__tstate);
31505 if (PyErr_Occurred()) SWIG_fail;
31506 }
31507 resultobj = SWIG_Py_Void();
31508 return resultobj;
31509 fail:
31510 return NULL;
31511 }
31512
31513
31514 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31515 PyObject *resultobj = 0;
31516 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31517 wxEvent *arg2 = 0 ;
31518 void *argp1 = 0 ;
31519 int res1 = 0 ;
31520 void *argp2 = 0 ;
31521 int res2 = 0 ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 char * kwnames[] = {
31525 (char *) "dest",(char *) "event", NULL
31526 };
31527
31528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31530 if (!SWIG_IsOK(res1)) {
31531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31532 }
31533 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31535 if (!SWIG_IsOK(res2)) {
31536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31537 }
31538 if (!argp2) {
31539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31540 }
31541 arg2 = reinterpret_cast< wxEvent * >(argp2);
31542 {
31543 PyThreadState* __tstate = wxPyBeginAllowThreads();
31544 wxPostEvent(arg1,*arg2);
31545 wxPyEndAllowThreads(__tstate);
31546 if (PyErr_Occurred()) SWIG_fail;
31547 }
31548 resultobj = SWIG_Py_Void();
31549 return resultobj;
31550 fail:
31551 return NULL;
31552 }
31553
31554
31555 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31556 PyObject *resultobj = 0;
31557
31558 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 wxApp_CleanUp();
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_Py_Void();
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574 wxPyApp *result = 0 ;
31575
31576 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 result = (wxPyApp *)wxPyGetApp();
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 {
31584 resultobj = wxPyMake_wxObject(result, 0);
31585 }
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj = 0;
31594 char *arg1 = (char *) 0 ;
31595 int res1 ;
31596 char *buf1 = 0 ;
31597 int alloc1 = 0 ;
31598 PyObject * obj0 = 0 ;
31599 char * kwnames[] = {
31600 (char *) "encoding", NULL
31601 };
31602
31603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31604 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31605 if (!SWIG_IsOK(res1)) {
31606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31607 }
31608 arg1 = buf1;
31609 {
31610 PyThreadState* __tstate = wxPyBeginAllowThreads();
31611 wxSetDefaultPyEncoding((char const *)arg1);
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 resultobj = SWIG_Py_Void();
31616 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31617 return resultobj;
31618 fail:
31619 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31620 return NULL;
31621 }
31622
31623
31624 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31625 PyObject *resultobj = 0;
31626 char *result = 0 ;
31627
31628 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 result = (char *)wxGetDefaultPyEncoding();
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 resultobj = SWIG_FromCharPtr(result);
31636 return resultobj;
31637 fail:
31638 return NULL;
31639 }
31640
31641
31642 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31643 PyObject *resultobj = 0;
31644 wxEventLoop *result = 0 ;
31645
31646 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 result = (wxEventLoop *)new wxEventLoop();
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31663 void *argp1 = 0 ;
31664 int res1 = 0 ;
31665 PyObject *swig_obj[1] ;
31666
31667 if (!args) SWIG_fail;
31668 swig_obj[0] = args;
31669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31670 if (!SWIG_IsOK(res1)) {
31671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31672 }
31673 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 delete arg1;
31677
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_Py_Void();
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31691 int result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31701 }
31702 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (int)(arg1)->Run();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_From_int(static_cast< int >(result));
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31719 int arg2 = (int) 0 ;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 int val2 ;
31723 int ecode2 = 0 ;
31724 PyObject * obj0 = 0 ;
31725 PyObject * obj1 = 0 ;
31726 char * kwnames[] = {
31727 (char *) "self",(char *) "rc", NULL
31728 };
31729
31730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31734 }
31735 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31736 if (obj1) {
31737 ecode2 = SWIG_AsVal_int(obj1, &val2);
31738 if (!SWIG_IsOK(ecode2)) {
31739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31740 }
31741 arg2 = static_cast< int >(val2);
31742 }
31743 {
31744 PyThreadState* __tstate = wxPyBeginAllowThreads();
31745 (arg1)->Exit(arg2);
31746 wxPyEndAllowThreads(__tstate);
31747 if (PyErr_Occurred()) SWIG_fail;
31748 }
31749 resultobj = SWIG_Py_Void();
31750 return resultobj;
31751 fail:
31752 return NULL;
31753 }
31754
31755
31756 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31757 PyObject *resultobj = 0;
31758 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31759 bool result;
31760 void *argp1 = 0 ;
31761 int res1 = 0 ;
31762 PyObject *swig_obj[1] ;
31763
31764 if (!args) SWIG_fail;
31765 swig_obj[0] = args;
31766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31769 }
31770 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 result = (bool)((wxEventLoop const *)arg1)->Pending();
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 {
31778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31779 }
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31789 bool result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31799 }
31800 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (bool)(arg1)->Dispatch();
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 {
31808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31809 }
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31819 bool result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 {
31838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31839 }
31840 return resultobj;
31841 fail:
31842 return NULL;
31843 }
31844
31845
31846 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 PyObject *resultobj = 0;
31848 wxEventLoop *result = 0 ;
31849
31850 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = (wxEventLoop *)wxEventLoop::GetActive();
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31865 PyObject *resultobj = 0;
31866 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 PyObject * obj0 = 0 ;
31870 char * kwnames[] = {
31871 (char *) "loop", NULL
31872 };
31873
31874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31878 }
31879 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 wxEventLoop::SetActive(arg1);
31883 wxPyEndAllowThreads(__tstate);
31884 if (PyErr_Occurred()) SWIG_fail;
31885 }
31886 resultobj = SWIG_Py_Void();
31887 return resultobj;
31888 fail:
31889 return NULL;
31890 }
31891
31892
31893 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31894 PyObject *obj;
31895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31896 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31897 return SWIG_Py_Void();
31898 }
31899
31900 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31901 return SWIG_Python_InitShadowInstance(args);
31902 }
31903
31904 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31905 PyObject *resultobj = 0;
31906 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31907 wxEventLoopActivator *result = 0 ;
31908 void *argp1 = 0 ;
31909 int res1 = 0 ;
31910 PyObject * obj0 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "evtLoop", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31919 }
31920 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *resultobj = 0;
31936 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31937 void *argp1 = 0 ;
31938 int res1 = 0 ;
31939 PyObject *swig_obj[1] ;
31940
31941 if (!args) SWIG_fail;
31942 swig_obj[0] = args;
31943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31946 }
31947 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 delete arg1;
31951
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 resultobj = SWIG_Py_Void();
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 PyObject *obj;
31964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31965 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31966 return SWIG_Py_Void();
31967 }
31968
31969 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31970 return SWIG_Python_InitShadowInstance(args);
31971 }
31972
31973 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj = 0;
31975 int arg1 = (int) 0 ;
31976 int arg2 = (int) 0 ;
31977 int arg3 = (int) 0 ;
31978 wxAcceleratorEntry *result = 0 ;
31979 int val1 ;
31980 int ecode1 = 0 ;
31981 int val2 ;
31982 int ecode2 = 0 ;
31983 int val3 ;
31984 int ecode3 = 0 ;
31985 PyObject * obj0 = 0 ;
31986 PyObject * obj1 = 0 ;
31987 PyObject * obj2 = 0 ;
31988 char * kwnames[] = {
31989 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31990 };
31991
31992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31993 if (obj0) {
31994 ecode1 = SWIG_AsVal_int(obj0, &val1);
31995 if (!SWIG_IsOK(ecode1)) {
31996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31997 }
31998 arg1 = static_cast< int >(val1);
31999 }
32000 if (obj1) {
32001 ecode2 = SWIG_AsVal_int(obj1, &val2);
32002 if (!SWIG_IsOK(ecode2)) {
32003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32004 }
32005 arg2 = static_cast< int >(val2);
32006 }
32007 if (obj2) {
32008 ecode3 = SWIG_AsVal_int(obj2, &val3);
32009 if (!SWIG_IsOK(ecode3)) {
32010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32011 }
32012 arg3 = static_cast< int >(val3);
32013 }
32014 {
32015 PyThreadState* __tstate = wxPyBeginAllowThreads();
32016 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32017 wxPyEndAllowThreads(__tstate);
32018 if (PyErr_Occurred()) SWIG_fail;
32019 }
32020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32028 PyObject *resultobj = 0;
32029 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32030 void *argp1 = 0 ;
32031 int res1 = 0 ;
32032 PyObject *swig_obj[1] ;
32033
32034 if (!args) SWIG_fail;
32035 swig_obj[0] = args;
32036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32037 if (!SWIG_IsOK(res1)) {
32038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32039 }
32040 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32041 {
32042 PyThreadState* __tstate = wxPyBeginAllowThreads();
32043 delete arg1;
32044
32045 wxPyEndAllowThreads(__tstate);
32046 if (PyErr_Occurred()) SWIG_fail;
32047 }
32048 resultobj = SWIG_Py_Void();
32049 return resultobj;
32050 fail:
32051 return NULL;
32052 }
32053
32054
32055 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32056 PyObject *resultobj = 0;
32057 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32058 int arg2 ;
32059 int arg3 ;
32060 int arg4 ;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 int val2 ;
32064 int ecode2 = 0 ;
32065 int val3 ;
32066 int ecode3 = 0 ;
32067 int val4 ;
32068 int ecode4 = 0 ;
32069 PyObject * obj0 = 0 ;
32070 PyObject * obj1 = 0 ;
32071 PyObject * obj2 = 0 ;
32072 PyObject * obj3 = 0 ;
32073 char * kwnames[] = {
32074 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32075 };
32076
32077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32079 if (!SWIG_IsOK(res1)) {
32080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32081 }
32082 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32083 ecode2 = SWIG_AsVal_int(obj1, &val2);
32084 if (!SWIG_IsOK(ecode2)) {
32085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32086 }
32087 arg2 = static_cast< int >(val2);
32088 ecode3 = SWIG_AsVal_int(obj2, &val3);
32089 if (!SWIG_IsOK(ecode3)) {
32090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32091 }
32092 arg3 = static_cast< int >(val3);
32093 ecode4 = SWIG_AsVal_int(obj3, &val4);
32094 if (!SWIG_IsOK(ecode4)) {
32095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32096 }
32097 arg4 = static_cast< int >(val4);
32098 {
32099 PyThreadState* __tstate = wxPyBeginAllowThreads();
32100 (arg1)->Set(arg2,arg3,arg4);
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 resultobj = SWIG_Py_Void();
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32112 PyObject *resultobj = 0;
32113 wxString *arg1 = 0 ;
32114 wxAcceleratorEntry *result = 0 ;
32115 bool temp1 = false ;
32116 PyObject * obj0 = 0 ;
32117 char * kwnames[] = {
32118 (char *) "str", NULL
32119 };
32120
32121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32122 {
32123 arg1 = wxString_in_helper(obj0);
32124 if (arg1 == NULL) SWIG_fail;
32125 temp1 = true;
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32134 {
32135 if (temp1)
32136 delete arg1;
32137 }
32138 return resultobj;
32139 fail:
32140 {
32141 if (temp1)
32142 delete arg1;
32143 }
32144 return NULL;
32145 }
32146
32147
32148 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32149 PyObject *resultobj = 0;
32150 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32151 int result;
32152 void *argp1 = 0 ;
32153 int res1 = 0 ;
32154 PyObject *swig_obj[1] ;
32155
32156 if (!args) SWIG_fail;
32157 swig_obj[0] = args;
32158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32159 if (!SWIG_IsOK(res1)) {
32160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32161 }
32162 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (int)(arg1)->GetFlags();
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_From_int(static_cast< int >(result));
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32179 int result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32189 }
32190 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (int)(arg1)->GetKeyCode();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 resultobj = SWIG_From_int(static_cast< int >(result));
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32207 int result;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 PyObject *swig_obj[1] ;
32211
32212 if (!args) SWIG_fail;
32213 swig_obj[0] = args;
32214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32215 if (!SWIG_IsOK(res1)) {
32216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32217 }
32218 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (int)(arg1)->GetCommand();
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 resultobj = SWIG_From_int(static_cast< int >(result));
32226 return resultobj;
32227 fail:
32228 return NULL;
32229 }
32230
32231
32232 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32233 PyObject *resultobj = 0;
32234 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32235 bool result;
32236 void *argp1 = 0 ;
32237 int res1 = 0 ;
32238 PyObject *swig_obj[1] ;
32239
32240 if (!args) SWIG_fail;
32241 swig_obj[0] = args;
32242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32245 }
32246 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 {
32254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32255 }
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 PyObject *resultobj = 0;
32264 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32265 wxString result;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 PyObject *swig_obj[1] ;
32269
32270 if (!args) SWIG_fail;
32271 swig_obj[0] = args;
32272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32275 }
32276 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 #if wxUSE_UNICODE
32285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32286 #else
32287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32288 #endif
32289 }
32290 return resultobj;
32291 fail:
32292 return NULL;
32293 }
32294
32295
32296 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32297 PyObject *resultobj = 0;
32298 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32299 wxString *arg2 = 0 ;
32300 bool result;
32301 void *argp1 = 0 ;
32302 int res1 = 0 ;
32303 bool temp2 = false ;
32304 PyObject * obj0 = 0 ;
32305 PyObject * obj1 = 0 ;
32306 char * kwnames[] = {
32307 (char *) "self",(char *) "str", NULL
32308 };
32309
32310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32312 if (!SWIG_IsOK(res1)) {
32313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32314 }
32315 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32316 {
32317 arg2 = wxString_in_helper(obj1);
32318 if (arg2 == NULL) SWIG_fail;
32319 temp2 = true;
32320 }
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32329 }
32330 {
32331 if (temp2)
32332 delete arg2;
32333 }
32334 return resultobj;
32335 fail:
32336 {
32337 if (temp2)
32338 delete arg2;
32339 }
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *obj;
32346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32347 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32348 return SWIG_Py_Void();
32349 }
32350
32351 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32352 return SWIG_Python_InitShadowInstance(args);
32353 }
32354
32355 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj = 0;
32357 int arg1 ;
32358 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32359 wxAcceleratorTable *result = 0 ;
32360 PyObject * obj0 = 0 ;
32361 char * kwnames[] = {
32362 (char *) "n", NULL
32363 };
32364
32365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32366 {
32367 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32368 if (arg2) arg1 = PyList_Size(obj0);
32369 else arg1 = 0;
32370 }
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32374 wxPyEndAllowThreads(__tstate);
32375 if (PyErr_Occurred()) SWIG_fail;
32376 }
32377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 PyObject *resultobj = 0;
32386 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32387 void *argp1 = 0 ;
32388 int res1 = 0 ;
32389 PyObject *swig_obj[1] ;
32390
32391 if (!args) SWIG_fail;
32392 swig_obj[0] = args;
32393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32396 }
32397 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 delete arg1;
32401
32402 wxPyEndAllowThreads(__tstate);
32403 if (PyErr_Occurred()) SWIG_fail;
32404 }
32405 resultobj = SWIG_Py_Void();
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32413 PyObject *resultobj = 0;
32414 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32415 bool result;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 PyObject *swig_obj[1] ;
32419
32420 if (!args) SWIG_fail;
32421 swig_obj[0] = args;
32422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32423 if (!SWIG_IsOK(res1)) {
32424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32425 }
32426 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 {
32434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32435 }
32436 return resultobj;
32437 fail:
32438 return NULL;
32439 }
32440
32441
32442 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32443 PyObject *obj;
32444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32445 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32446 return SWIG_Py_Void();
32447 }
32448
32449 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32450 return SWIG_Python_InitShadowInstance(args);
32451 }
32452
32453 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32454 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32455 return 1;
32456 }
32457
32458
32459 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32460 PyObject *pyobj = 0;
32461
32462 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32463 return pyobj;
32464 }
32465
32466
32467 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32468 PyObject *resultobj = 0;
32469 wxString *arg1 = 0 ;
32470 wxAcceleratorEntry *result = 0 ;
32471 bool temp1 = false ;
32472 PyObject * obj0 = 0 ;
32473 char * kwnames[] = {
32474 (char *) "label", NULL
32475 };
32476
32477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32478 {
32479 arg1 = wxString_in_helper(obj0);
32480 if (arg1 == NULL) SWIG_fail;
32481 temp1 = true;
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32490 {
32491 if (temp1)
32492 delete arg1;
32493 }
32494 return resultobj;
32495 fail:
32496 {
32497 if (temp1)
32498 delete arg1;
32499 }
32500 return NULL;
32501 }
32502
32503
32504 SWIGINTERN int PanelNameStr_set(PyObject *) {
32505 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32506 return 1;
32507 }
32508
32509
32510 SWIGINTERN PyObject *PanelNameStr_get(void) {
32511 PyObject *pyobj = 0;
32512
32513 {
32514 #if wxUSE_UNICODE
32515 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32516 #else
32517 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32518 #endif
32519 }
32520 return pyobj;
32521 }
32522
32523
32524 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32525 PyObject *resultobj = 0;
32526 wxVisualAttributes *result = 0 ;
32527
32528 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32529 {
32530 PyThreadState* __tstate = wxPyBeginAllowThreads();
32531 result = (wxVisualAttributes *)new_wxVisualAttributes();
32532 wxPyEndAllowThreads(__tstate);
32533 if (PyErr_Occurred()) SWIG_fail;
32534 }
32535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32536 return resultobj;
32537 fail:
32538 return NULL;
32539 }
32540
32541
32542 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32543 PyObject *resultobj = 0;
32544 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32545 void *argp1 = 0 ;
32546 int res1 = 0 ;
32547 PyObject *swig_obj[1] ;
32548
32549 if (!args) SWIG_fail;
32550 swig_obj[0] = args;
32551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32554 }
32555 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32556 {
32557 PyThreadState* __tstate = wxPyBeginAllowThreads();
32558 delete_wxVisualAttributes(arg1);
32559
32560 wxPyEndAllowThreads(__tstate);
32561 if (PyErr_Occurred()) SWIG_fail;
32562 }
32563 resultobj = SWIG_Py_Void();
32564 return resultobj;
32565 fail:
32566 return NULL;
32567 }
32568
32569
32570 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32571 PyObject *resultobj = 0;
32572 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32573 wxFont *arg2 = (wxFont *) 0 ;
32574 void *argp1 = 0 ;
32575 int res1 = 0 ;
32576 void *argp2 = 0 ;
32577 int res2 = 0 ;
32578 PyObject *swig_obj[2] ;
32579
32580 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32584 }
32585 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32586 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32587 if (!SWIG_IsOK(res2)) {
32588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32589 }
32590 arg2 = reinterpret_cast< wxFont * >(argp2);
32591 if (arg1) (arg1)->font = *arg2;
32592
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 PyObject *resultobj = 0;
32602 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32603 wxFont *result = 0 ;
32604 void *argp1 = 0 ;
32605 int res1 = 0 ;
32606 PyObject *swig_obj[1] ;
32607
32608 if (!args) SWIG_fail;
32609 swig_obj[0] = args;
32610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32613 }
32614 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32615 result = (wxFont *)& ((arg1)->font);
32616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32617 return resultobj;
32618 fail:
32619 return NULL;
32620 }
32621
32622
32623 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32624 PyObject *resultobj = 0;
32625 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32626 wxColour *arg2 = (wxColour *) 0 ;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 void *argp2 = 0 ;
32630 int res2 = 0 ;
32631 PyObject *swig_obj[2] ;
32632
32633 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32635 if (!SWIG_IsOK(res1)) {
32636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32637 }
32638 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32639 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32640 if (!SWIG_IsOK(res2)) {
32641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32642 }
32643 arg2 = reinterpret_cast< wxColour * >(argp2);
32644 if (arg1) (arg1)->colFg = *arg2;
32645
32646 resultobj = SWIG_Py_Void();
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 PyObject *resultobj = 0;
32655 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32656 wxColour *result = 0 ;
32657 void *argp1 = 0 ;
32658 int res1 = 0 ;
32659 PyObject *swig_obj[1] ;
32660
32661 if (!args) SWIG_fail;
32662 swig_obj[0] = args;
32663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32664 if (!SWIG_IsOK(res1)) {
32665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32666 }
32667 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32668 result = (wxColour *)& ((arg1)->colFg);
32669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *resultobj = 0;
32678 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32679 wxColour *arg2 = (wxColour *) 0 ;
32680 void *argp1 = 0 ;
32681 int res1 = 0 ;
32682 void *argp2 = 0 ;
32683 int res2 = 0 ;
32684 PyObject *swig_obj[2] ;
32685
32686 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32688 if (!SWIG_IsOK(res1)) {
32689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32690 }
32691 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32692 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32693 if (!SWIG_IsOK(res2)) {
32694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32695 }
32696 arg2 = reinterpret_cast< wxColour * >(argp2);
32697 if (arg1) (arg1)->colBg = *arg2;
32698
32699 resultobj = SWIG_Py_Void();
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32707 PyObject *resultobj = 0;
32708 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32709 wxColour *result = 0 ;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 PyObject *swig_obj[1] ;
32713
32714 if (!args) SWIG_fail;
32715 swig_obj[0] = args;
32716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32719 }
32720 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32721 result = (wxColour *)& ((arg1)->colBg);
32722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32723 return resultobj;
32724 fail:
32725 return NULL;
32726 }
32727
32728
32729 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32730 PyObject *obj;
32731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32732 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32733 return SWIG_Py_Void();
32734 }
32735
32736 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32737 return SWIG_Python_InitShadowInstance(args);
32738 }
32739
32740 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32741 PyObject *resultobj = 0;
32742 wxWindow *arg1 = (wxWindow *) 0 ;
32743 int arg2 = (int) (int)-1 ;
32744 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32745 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32746 wxSize const &arg4_defvalue = wxDefaultSize ;
32747 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32748 long arg5 = (long) 0 ;
32749 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32750 wxString *arg6 = (wxString *) &arg6_defvalue ;
32751 wxWindow *result = 0 ;
32752 void *argp1 = 0 ;
32753 int res1 = 0 ;
32754 int val2 ;
32755 int ecode2 = 0 ;
32756 wxPoint temp3 ;
32757 wxSize temp4 ;
32758 long val5 ;
32759 int ecode5 = 0 ;
32760 bool temp6 = false ;
32761 PyObject * obj0 = 0 ;
32762 PyObject * obj1 = 0 ;
32763 PyObject * obj2 = 0 ;
32764 PyObject * obj3 = 0 ;
32765 PyObject * obj4 = 0 ;
32766 PyObject * obj5 = 0 ;
32767 char * kwnames[] = {
32768 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32769 };
32770
32771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32773 if (!SWIG_IsOK(res1)) {
32774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32775 }
32776 arg1 = reinterpret_cast< wxWindow * >(argp1);
32777 if (obj1) {
32778 ecode2 = SWIG_AsVal_int(obj1, &val2);
32779 if (!SWIG_IsOK(ecode2)) {
32780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32781 }
32782 arg2 = static_cast< int >(val2);
32783 }
32784 if (obj2) {
32785 {
32786 arg3 = &temp3;
32787 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32788 }
32789 }
32790 if (obj3) {
32791 {
32792 arg4 = &temp4;
32793 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32794 }
32795 }
32796 if (obj4) {
32797 ecode5 = SWIG_AsVal_long(obj4, &val5);
32798 if (!SWIG_IsOK(ecode5)) {
32799 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32800 }
32801 arg5 = static_cast< long >(val5);
32802 }
32803 if (obj5) {
32804 {
32805 arg6 = wxString_in_helper(obj5);
32806 if (arg6 == NULL) SWIG_fail;
32807 temp6 = true;
32808 }
32809 }
32810 {
32811 if (!wxPyCheckForApp()) SWIG_fail;
32812 PyThreadState* __tstate = wxPyBeginAllowThreads();
32813 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32814 wxPyEndAllowThreads(__tstate);
32815 if (PyErr_Occurred()) SWIG_fail;
32816 }
32817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32818 {
32819 if (temp6)
32820 delete arg6;
32821 }
32822 return resultobj;
32823 fail:
32824 {
32825 if (temp6)
32826 delete arg6;
32827 }
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxWindow *result = 0 ;
32835
32836 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32837 {
32838 if (!wxPyCheckForApp()) SWIG_fail;
32839 PyThreadState* __tstate = wxPyBeginAllowThreads();
32840 result = (wxWindow *)new wxWindow();
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32845 return resultobj;
32846 fail:
32847 return NULL;
32848 }
32849
32850
32851 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32852 PyObject *resultobj = 0;
32853 wxWindow *arg1 = (wxWindow *) 0 ;
32854 wxWindow *arg2 = (wxWindow *) 0 ;
32855 int arg3 = (int) (int)-1 ;
32856 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32857 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32858 wxSize const &arg5_defvalue = wxDefaultSize ;
32859 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32860 long arg6 = (long) 0 ;
32861 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32862 wxString *arg7 = (wxString *) &arg7_defvalue ;
32863 bool result;
32864 void *argp1 = 0 ;
32865 int res1 = 0 ;
32866 void *argp2 = 0 ;
32867 int res2 = 0 ;
32868 int val3 ;
32869 int ecode3 = 0 ;
32870 wxPoint temp4 ;
32871 wxSize temp5 ;
32872 long val6 ;
32873 int ecode6 = 0 ;
32874 bool temp7 = false ;
32875 PyObject * obj0 = 0 ;
32876 PyObject * obj1 = 0 ;
32877 PyObject * obj2 = 0 ;
32878 PyObject * obj3 = 0 ;
32879 PyObject * obj4 = 0 ;
32880 PyObject * obj5 = 0 ;
32881 PyObject * obj6 = 0 ;
32882 char * kwnames[] = {
32883 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32884 };
32885
32886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res1)) {
32889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32890 }
32891 arg1 = reinterpret_cast< wxWindow * >(argp1);
32892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32893 if (!SWIG_IsOK(res2)) {
32894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32895 }
32896 arg2 = reinterpret_cast< wxWindow * >(argp2);
32897 if (obj2) {
32898 ecode3 = SWIG_AsVal_int(obj2, &val3);
32899 if (!SWIG_IsOK(ecode3)) {
32900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32901 }
32902 arg3 = static_cast< int >(val3);
32903 }
32904 if (obj3) {
32905 {
32906 arg4 = &temp4;
32907 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32908 }
32909 }
32910 if (obj4) {
32911 {
32912 arg5 = &temp5;
32913 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32914 }
32915 }
32916 if (obj5) {
32917 ecode6 = SWIG_AsVal_long(obj5, &val6);
32918 if (!SWIG_IsOK(ecode6)) {
32919 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32920 }
32921 arg6 = static_cast< long >(val6);
32922 }
32923 if (obj6) {
32924 {
32925 arg7 = wxString_in_helper(obj6);
32926 if (arg7 == NULL) SWIG_fail;
32927 temp7 = true;
32928 }
32929 }
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 {
32937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32938 }
32939 {
32940 if (temp7)
32941 delete arg7;
32942 }
32943 return resultobj;
32944 fail:
32945 {
32946 if (temp7)
32947 delete arg7;
32948 }
32949 return NULL;
32950 }
32951
32952
32953 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32954 PyObject *resultobj = 0;
32955 wxWindow *arg1 = (wxWindow *) 0 ;
32956 bool arg2 = (bool) false ;
32957 bool result;
32958 void *argp1 = 0 ;
32959 int res1 = 0 ;
32960 bool val2 ;
32961 int ecode2 = 0 ;
32962 PyObject * obj0 = 0 ;
32963 PyObject * obj1 = 0 ;
32964 char * kwnames[] = {
32965 (char *) "self",(char *) "force", NULL
32966 };
32967
32968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32970 if (!SWIG_IsOK(res1)) {
32971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32972 }
32973 arg1 = reinterpret_cast< wxWindow * >(argp1);
32974 if (obj1) {
32975 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32976 if (!SWIG_IsOK(ecode2)) {
32977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32978 }
32979 arg2 = static_cast< bool >(val2);
32980 }
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (bool)(arg1)->Close(arg2);
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject *swig_obj[1] ;
33003
33004 if (!args) SWIG_fail;
33005 swig_obj[0] = args;
33006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)(arg1)->Destroy();
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 bool result;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 PyObject *swig_obj[1] ;
33033
33034 if (!args) SWIG_fail;
33035 swig_obj[0] = args;
33036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33039 }
33040 arg1 = reinterpret_cast< wxWindow * >(argp1);
33041 {
33042 PyThreadState* __tstate = wxPyBeginAllowThreads();
33043 result = (bool)(arg1)->DestroyChildren();
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 {
33048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33049 }
33050 return resultobj;
33051 fail:
33052 return NULL;
33053 }
33054
33055
33056 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33057 PyObject *resultobj = 0;
33058 wxWindow *arg1 = (wxWindow *) 0 ;
33059 bool result;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 PyObject *swig_obj[1] ;
33063
33064 if (!args) SWIG_fail;
33065 swig_obj[0] = args;
33066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33067 if (!SWIG_IsOK(res1)) {
33068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33069 }
33070 arg1 = reinterpret_cast< wxWindow * >(argp1);
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 {
33078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33079 }
33080 return resultobj;
33081 fail:
33082 return NULL;
33083 }
33084
33085
33086 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33087 PyObject *resultobj = 0;
33088 wxWindow *arg1 = (wxWindow *) 0 ;
33089 wxString *arg2 = 0 ;
33090 void *argp1 = 0 ;
33091 int res1 = 0 ;
33092 bool temp2 = false ;
33093 PyObject * obj0 = 0 ;
33094 PyObject * obj1 = 0 ;
33095 char * kwnames[] = {
33096 (char *) "self",(char *) "label", NULL
33097 };
33098
33099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33101 if (!SWIG_IsOK(res1)) {
33102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33103 }
33104 arg1 = reinterpret_cast< wxWindow * >(argp1);
33105 {
33106 arg2 = wxString_in_helper(obj1);
33107 if (arg2 == NULL) SWIG_fail;
33108 temp2 = true;
33109 }
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 (arg1)->SetLabel((wxString const &)*arg2);
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 resultobj = SWIG_Py_Void();
33117 {
33118 if (temp2)
33119 delete arg2;
33120 }
33121 return resultobj;
33122 fail:
33123 {
33124 if (temp2)
33125 delete arg2;
33126 }
33127 return NULL;
33128 }
33129
33130
33131 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33132 PyObject *resultobj = 0;
33133 wxWindow *arg1 = (wxWindow *) 0 ;
33134 wxString result;
33135 void *argp1 = 0 ;
33136 int res1 = 0 ;
33137 PyObject *swig_obj[1] ;
33138
33139 if (!args) SWIG_fail;
33140 swig_obj[0] = args;
33141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33142 if (!SWIG_IsOK(res1)) {
33143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33144 }
33145 arg1 = reinterpret_cast< wxWindow * >(argp1);
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = ((wxWindow const *)arg1)->GetLabel();
33149 wxPyEndAllowThreads(__tstate);
33150 if (PyErr_Occurred()) SWIG_fail;
33151 }
33152 {
33153 #if wxUSE_UNICODE
33154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33155 #else
33156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33157 #endif
33158 }
33159 return resultobj;
33160 fail:
33161 return NULL;
33162 }
33163
33164
33165 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj = 0;
33167 wxWindow *arg1 = (wxWindow *) 0 ;
33168 wxString *arg2 = 0 ;
33169 void *argp1 = 0 ;
33170 int res1 = 0 ;
33171 bool temp2 = false ;
33172 PyObject * obj0 = 0 ;
33173 PyObject * obj1 = 0 ;
33174 char * kwnames[] = {
33175 (char *) "self",(char *) "name", NULL
33176 };
33177
33178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33180 if (!SWIG_IsOK(res1)) {
33181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33182 }
33183 arg1 = reinterpret_cast< wxWindow * >(argp1);
33184 {
33185 arg2 = wxString_in_helper(obj1);
33186 if (arg2 == NULL) SWIG_fail;
33187 temp2 = true;
33188 }
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 (arg1)->SetName((wxString const &)*arg2);
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 resultobj = SWIG_Py_Void();
33196 {
33197 if (temp2)
33198 delete arg2;
33199 }
33200 return resultobj;
33201 fail:
33202 {
33203 if (temp2)
33204 delete arg2;
33205 }
33206 return NULL;
33207 }
33208
33209
33210 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33211 PyObject *resultobj = 0;
33212 wxWindow *arg1 = (wxWindow *) 0 ;
33213 wxString result;
33214 void *argp1 = 0 ;
33215 int res1 = 0 ;
33216 PyObject *swig_obj[1] ;
33217
33218 if (!args) SWIG_fail;
33219 swig_obj[0] = args;
33220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33221 if (!SWIG_IsOK(res1)) {
33222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33223 }
33224 arg1 = reinterpret_cast< wxWindow * >(argp1);
33225 {
33226 PyThreadState* __tstate = wxPyBeginAllowThreads();
33227 result = ((wxWindow const *)arg1)->GetName();
33228 wxPyEndAllowThreads(__tstate);
33229 if (PyErr_Occurred()) SWIG_fail;
33230 }
33231 {
33232 #if wxUSE_UNICODE
33233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33234 #else
33235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33236 #endif
33237 }
33238 return resultobj;
33239 fail:
33240 return NULL;
33241 }
33242
33243
33244 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33245 PyObject *resultobj = 0;
33246 wxWindow *arg1 = (wxWindow *) 0 ;
33247 wxWindowVariant arg2 ;
33248 void *argp1 = 0 ;
33249 int res1 = 0 ;
33250 int val2 ;
33251 int ecode2 = 0 ;
33252 PyObject * obj0 = 0 ;
33253 PyObject * obj1 = 0 ;
33254 char * kwnames[] = {
33255 (char *) "self",(char *) "variant", NULL
33256 };
33257
33258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33260 if (!SWIG_IsOK(res1)) {
33261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33262 }
33263 arg1 = reinterpret_cast< wxWindow * >(argp1);
33264 ecode2 = SWIG_AsVal_int(obj1, &val2);
33265 if (!SWIG_IsOK(ecode2)) {
33266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33267 }
33268 arg2 = static_cast< wxWindowVariant >(val2);
33269 {
33270 PyThreadState* __tstate = wxPyBeginAllowThreads();
33271 (arg1)->SetWindowVariant(arg2);
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 resultobj = SWIG_Py_Void();
33276 return resultobj;
33277 fail:
33278 return NULL;
33279 }
33280
33281
33282 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33283 PyObject *resultobj = 0;
33284 wxWindow *arg1 = (wxWindow *) 0 ;
33285 wxWindowVariant result;
33286 void *argp1 = 0 ;
33287 int res1 = 0 ;
33288 PyObject *swig_obj[1] ;
33289
33290 if (!args) SWIG_fail;
33291 swig_obj[0] = args;
33292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33293 if (!SWIG_IsOK(res1)) {
33294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33295 }
33296 arg1 = reinterpret_cast< wxWindow * >(argp1);
33297 {
33298 PyThreadState* __tstate = wxPyBeginAllowThreads();
33299 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33300 wxPyEndAllowThreads(__tstate);
33301 if (PyErr_Occurred()) SWIG_fail;
33302 }
33303 resultobj = SWIG_From_int(static_cast< int >(result));
33304 return resultobj;
33305 fail:
33306 return NULL;
33307 }
33308
33309
33310 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33311 PyObject *resultobj = 0;
33312 wxWindow *arg1 = (wxWindow *) 0 ;
33313 int arg2 ;
33314 void *argp1 = 0 ;
33315 int res1 = 0 ;
33316 int val2 ;
33317 int ecode2 = 0 ;
33318 PyObject * obj0 = 0 ;
33319 PyObject * obj1 = 0 ;
33320 char * kwnames[] = {
33321 (char *) "self",(char *) "winid", NULL
33322 };
33323
33324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33326 if (!SWIG_IsOK(res1)) {
33327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33328 }
33329 arg1 = reinterpret_cast< wxWindow * >(argp1);
33330 ecode2 = SWIG_AsVal_int(obj1, &val2);
33331 if (!SWIG_IsOK(ecode2)) {
33332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33333 }
33334 arg2 = static_cast< int >(val2);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 (arg1)->SetId(arg2);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 resultobj = SWIG_Py_Void();
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33349 PyObject *resultobj = 0;
33350 wxWindow *arg1 = (wxWindow *) 0 ;
33351 int result;
33352 void *argp1 = 0 ;
33353 int res1 = 0 ;
33354 PyObject *swig_obj[1] ;
33355
33356 if (!args) SWIG_fail;
33357 swig_obj[0] = args;
33358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33359 if (!SWIG_IsOK(res1)) {
33360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33361 }
33362 arg1 = reinterpret_cast< wxWindow * >(argp1);
33363 {
33364 PyThreadState* __tstate = wxPyBeginAllowThreads();
33365 result = (int)((wxWindow const *)arg1)->GetId();
33366 wxPyEndAllowThreads(__tstate);
33367 if (PyErr_Occurred()) SWIG_fail;
33368 }
33369 resultobj = SWIG_From_int(static_cast< int >(result));
33370 return resultobj;
33371 fail:
33372 return NULL;
33373 }
33374
33375
33376 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33377 PyObject *resultobj = 0;
33378 int result;
33379
33380 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33381 {
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 result = (int)wxWindow::NewControlId();
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 resultobj = SWIG_From_int(static_cast< int >(result));
33388 return resultobj;
33389 fail:
33390 return NULL;
33391 }
33392
33393
33394 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33395 PyObject *resultobj = 0;
33396 int arg1 ;
33397 int result;
33398 int val1 ;
33399 int ecode1 = 0 ;
33400 PyObject * obj0 = 0 ;
33401 char * kwnames[] = {
33402 (char *) "winid", NULL
33403 };
33404
33405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33406 ecode1 = SWIG_AsVal_int(obj0, &val1);
33407 if (!SWIG_IsOK(ecode1)) {
33408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33409 }
33410 arg1 = static_cast< int >(val1);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 result = (int)wxWindow::NextControlId(arg1);
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 resultobj = SWIG_From_int(static_cast< int >(result));
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj = 0;
33426 int arg1 ;
33427 int result;
33428 int val1 ;
33429 int ecode1 = 0 ;
33430 PyObject * obj0 = 0 ;
33431 char * kwnames[] = {
33432 (char *) "winid", NULL
33433 };
33434
33435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33436 ecode1 = SWIG_AsVal_int(obj0, &val1);
33437 if (!SWIG_IsOK(ecode1)) {
33438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33439 }
33440 arg1 = static_cast< int >(val1);
33441 {
33442 PyThreadState* __tstate = wxPyBeginAllowThreads();
33443 result = (int)wxWindow::PrevControlId(arg1);
33444 wxPyEndAllowThreads(__tstate);
33445 if (PyErr_Occurred()) SWIG_fail;
33446 }
33447 resultobj = SWIG_From_int(static_cast< int >(result));
33448 return resultobj;
33449 fail:
33450 return NULL;
33451 }
33452
33453
33454 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33455 PyObject *resultobj = 0;
33456 wxWindow *arg1 = (wxWindow *) 0 ;
33457 wxLayoutDirection result;
33458 void *argp1 = 0 ;
33459 int res1 = 0 ;
33460 PyObject *swig_obj[1] ;
33461
33462 if (!args) SWIG_fail;
33463 swig_obj[0] = args;
33464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33465 if (!SWIG_IsOK(res1)) {
33466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33467 }
33468 arg1 = reinterpret_cast< wxWindow * >(argp1);
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 resultobj = SWIG_From_int(static_cast< int >(result));
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33483 PyObject *resultobj = 0;
33484 wxWindow *arg1 = (wxWindow *) 0 ;
33485 wxLayoutDirection arg2 ;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 int val2 ;
33489 int ecode2 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 char * kwnames[] = {
33493 (char *) "self",(char *) "dir", NULL
33494 };
33495
33496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33498 if (!SWIG_IsOK(res1)) {
33499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33500 }
33501 arg1 = reinterpret_cast< wxWindow * >(argp1);
33502 ecode2 = SWIG_AsVal_int(obj1, &val2);
33503 if (!SWIG_IsOK(ecode2)) {
33504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33505 }
33506 arg2 = static_cast< wxLayoutDirection >(val2);
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 (arg1)->SetLayoutDirection(arg2);
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 resultobj = SWIG_Py_Void();
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 wxWindow *arg1 = (wxWindow *) 0 ;
33523 int arg2 ;
33524 int arg3 ;
33525 int arg4 ;
33526 int result;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 int val2 ;
33530 int ecode2 = 0 ;
33531 int val3 ;
33532 int ecode3 = 0 ;
33533 int val4 ;
33534 int ecode4 = 0 ;
33535 PyObject * obj0 = 0 ;
33536 PyObject * obj1 = 0 ;
33537 PyObject * obj2 = 0 ;
33538 PyObject * obj3 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33547 }
33548 arg1 = reinterpret_cast< wxWindow * >(argp1);
33549 ecode2 = SWIG_AsVal_int(obj1, &val2);
33550 if (!SWIG_IsOK(ecode2)) {
33551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33552 }
33553 arg2 = static_cast< int >(val2);
33554 ecode3 = SWIG_AsVal_int(obj2, &val3);
33555 if (!SWIG_IsOK(ecode3)) {
33556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33557 }
33558 arg3 = static_cast< int >(val3);
33559 ecode4 = SWIG_AsVal_int(obj3, &val4);
33560 if (!SWIG_IsOK(ecode4)) {
33561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33562 }
33563 arg4 = static_cast< int >(val4);
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 resultobj = SWIG_From_int(static_cast< int >(result));
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj = 0;
33579 wxWindow *arg1 = (wxWindow *) 0 ;
33580 wxSize *arg2 = 0 ;
33581 void *argp1 = 0 ;
33582 int res1 = 0 ;
33583 wxSize temp2 ;
33584 PyObject * obj0 = 0 ;
33585 PyObject * obj1 = 0 ;
33586 char * kwnames[] = {
33587 (char *) "self",(char *) "size", NULL
33588 };
33589
33590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33592 if (!SWIG_IsOK(res1)) {
33593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33594 }
33595 arg1 = reinterpret_cast< wxWindow * >(argp1);
33596 {
33597 arg2 = &temp2;
33598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33599 }
33600 {
33601 PyThreadState* __tstate = wxPyBeginAllowThreads();
33602 (arg1)->SetSize((wxSize const &)*arg2);
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 resultobj = SWIG_Py_Void();
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 int arg2 ;
33617 int arg3 ;
33618 int arg4 ;
33619 int arg5 ;
33620 int arg6 = (int) wxSIZE_AUTO ;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 int val2 ;
33624 int ecode2 = 0 ;
33625 int val3 ;
33626 int ecode3 = 0 ;
33627 int val4 ;
33628 int ecode4 = 0 ;
33629 int val5 ;
33630 int ecode5 = 0 ;
33631 int val6 ;
33632 int ecode6 = 0 ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 PyObject * obj2 = 0 ;
33636 PyObject * obj3 = 0 ;
33637 PyObject * obj4 = 0 ;
33638 PyObject * obj5 = 0 ;
33639 char * kwnames[] = {
33640 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33641 };
33642
33643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33645 if (!SWIG_IsOK(res1)) {
33646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33647 }
33648 arg1 = reinterpret_cast< wxWindow * >(argp1);
33649 ecode2 = SWIG_AsVal_int(obj1, &val2);
33650 if (!SWIG_IsOK(ecode2)) {
33651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33652 }
33653 arg2 = static_cast< int >(val2);
33654 ecode3 = SWIG_AsVal_int(obj2, &val3);
33655 if (!SWIG_IsOK(ecode3)) {
33656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33657 }
33658 arg3 = static_cast< int >(val3);
33659 ecode4 = SWIG_AsVal_int(obj3, &val4);
33660 if (!SWIG_IsOK(ecode4)) {
33661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33662 }
33663 arg4 = static_cast< int >(val4);
33664 ecode5 = SWIG_AsVal_int(obj4, &val5);
33665 if (!SWIG_IsOK(ecode5)) {
33666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33667 }
33668 arg5 = static_cast< int >(val5);
33669 if (obj5) {
33670 ecode6 = SWIG_AsVal_int(obj5, &val6);
33671 if (!SWIG_IsOK(ecode6)) {
33672 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33673 }
33674 arg6 = static_cast< int >(val6);
33675 }
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33679 wxPyEndAllowThreads(__tstate);
33680 if (PyErr_Occurred()) SWIG_fail;
33681 }
33682 resultobj = SWIG_Py_Void();
33683 return resultobj;
33684 fail:
33685 return NULL;
33686 }
33687
33688
33689 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33690 PyObject *resultobj = 0;
33691 wxWindow *arg1 = (wxWindow *) 0 ;
33692 wxRect *arg2 = 0 ;
33693 int arg3 = (int) wxSIZE_AUTO ;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 wxRect temp2 ;
33697 int val3 ;
33698 int ecode3 = 0 ;
33699 PyObject * obj0 = 0 ;
33700 PyObject * obj1 = 0 ;
33701 PyObject * obj2 = 0 ;
33702 char * kwnames[] = {
33703 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33704 };
33705
33706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33708 if (!SWIG_IsOK(res1)) {
33709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33710 }
33711 arg1 = reinterpret_cast< wxWindow * >(argp1);
33712 {
33713 arg2 = &temp2;
33714 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33715 }
33716 if (obj2) {
33717 ecode3 = SWIG_AsVal_int(obj2, &val3);
33718 if (!SWIG_IsOK(ecode3)) {
33719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33720 }
33721 arg3 = static_cast< int >(val3);
33722 }
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33726 wxPyEndAllowThreads(__tstate);
33727 if (PyErr_Occurred()) SWIG_fail;
33728 }
33729 resultobj = SWIG_Py_Void();
33730 return resultobj;
33731 fail:
33732 return NULL;
33733 }
33734
33735
33736 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33737 PyObject *resultobj = 0;
33738 wxWindow *arg1 = (wxWindow *) 0 ;
33739 int arg2 ;
33740 int arg3 ;
33741 void *argp1 = 0 ;
33742 int res1 = 0 ;
33743 int val2 ;
33744 int ecode2 = 0 ;
33745 int val3 ;
33746 int ecode3 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 PyObject * obj2 = 0 ;
33750 char * kwnames[] = {
33751 (char *) "self",(char *) "width",(char *) "height", NULL
33752 };
33753
33754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33756 if (!SWIG_IsOK(res1)) {
33757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33758 }
33759 arg1 = reinterpret_cast< wxWindow * >(argp1);
33760 ecode2 = SWIG_AsVal_int(obj1, &val2);
33761 if (!SWIG_IsOK(ecode2)) {
33762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33763 }
33764 arg2 = static_cast< int >(val2);
33765 ecode3 = SWIG_AsVal_int(obj2, &val3);
33766 if (!SWIG_IsOK(ecode3)) {
33767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33768 }
33769 arg3 = static_cast< int >(val3);
33770 {
33771 PyThreadState* __tstate = wxPyBeginAllowThreads();
33772 (arg1)->SetSize(arg2,arg3);
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 resultobj = SWIG_Py_Void();
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj = 0;
33785 wxWindow *arg1 = (wxWindow *) 0 ;
33786 wxPoint *arg2 = 0 ;
33787 int arg3 = (int) wxSIZE_USE_EXISTING ;
33788 void *argp1 = 0 ;
33789 int res1 = 0 ;
33790 wxPoint temp2 ;
33791 int val3 ;
33792 int ecode3 = 0 ;
33793 PyObject * obj0 = 0 ;
33794 PyObject * obj1 = 0 ;
33795 PyObject * obj2 = 0 ;
33796 char * kwnames[] = {
33797 (char *) "self",(char *) "pt",(char *) "flags", NULL
33798 };
33799
33800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33802 if (!SWIG_IsOK(res1)) {
33803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33804 }
33805 arg1 = reinterpret_cast< wxWindow * >(argp1);
33806 {
33807 arg2 = &temp2;
33808 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33809 }
33810 if (obj2) {
33811 ecode3 = SWIG_AsVal_int(obj2, &val3);
33812 if (!SWIG_IsOK(ecode3)) {
33813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33814 }
33815 arg3 = static_cast< int >(val3);
33816 }
33817 {
33818 PyThreadState* __tstate = wxPyBeginAllowThreads();
33819 (arg1)->Move((wxPoint const &)*arg2,arg3);
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 resultobj = SWIG_Py_Void();
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33831 PyObject *resultobj = 0;
33832 wxWindow *arg1 = (wxWindow *) 0 ;
33833 int arg2 ;
33834 int arg3 ;
33835 int arg4 = (int) wxSIZE_USE_EXISTING ;
33836 void *argp1 = 0 ;
33837 int res1 = 0 ;
33838 int val2 ;
33839 int ecode2 = 0 ;
33840 int val3 ;
33841 int ecode3 = 0 ;
33842 int val4 ;
33843 int ecode4 = 0 ;
33844 PyObject * obj0 = 0 ;
33845 PyObject * obj1 = 0 ;
33846 PyObject * obj2 = 0 ;
33847 PyObject * obj3 = 0 ;
33848 char * kwnames[] = {
33849 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33850 };
33851
33852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33856 }
33857 arg1 = reinterpret_cast< wxWindow * >(argp1);
33858 ecode2 = SWIG_AsVal_int(obj1, &val2);
33859 if (!SWIG_IsOK(ecode2)) {
33860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33861 }
33862 arg2 = static_cast< int >(val2);
33863 ecode3 = SWIG_AsVal_int(obj2, &val3);
33864 if (!SWIG_IsOK(ecode3)) {
33865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33866 }
33867 arg3 = static_cast< int >(val3);
33868 if (obj3) {
33869 ecode4 = SWIG_AsVal_int(obj3, &val4);
33870 if (!SWIG_IsOK(ecode4)) {
33871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33872 }
33873 arg4 = static_cast< int >(val4);
33874 }
33875 {
33876 PyThreadState* __tstate = wxPyBeginAllowThreads();
33877 (arg1)->Move(arg2,arg3,arg4);
33878 wxPyEndAllowThreads(__tstate);
33879 if (PyErr_Occurred()) SWIG_fail;
33880 }
33881 resultobj = SWIG_Py_Void();
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33889 PyObject *resultobj = 0;
33890 wxWindow *arg1 = (wxWindow *) 0 ;
33891 wxSize const &arg2_defvalue = wxDefaultSize ;
33892 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33893 void *argp1 = 0 ;
33894 int res1 = 0 ;
33895 wxSize temp2 ;
33896 PyObject * obj0 = 0 ;
33897 PyObject * obj1 = 0 ;
33898 char * kwnames[] = {
33899 (char *) "self",(char *) "size", NULL
33900 };
33901
33902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
33903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33904 if (!SWIG_IsOK(res1)) {
33905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33906 }
33907 arg1 = reinterpret_cast< wxWindow * >(argp1);
33908 if (obj1) {
33909 {
33910 arg2 = &temp2;
33911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33912 }
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_Py_Void();
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33928 PyObject *resultobj = 0;
33929 wxWindow *arg1 = (wxWindow *) 0 ;
33930 void *argp1 = 0 ;
33931 int res1 = 0 ;
33932 PyObject *swig_obj[1] ;
33933
33934 if (!args) SWIG_fail;
33935 swig_obj[0] = args;
33936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33937 if (!SWIG_IsOK(res1)) {
33938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33939 }
33940 arg1 = reinterpret_cast< wxWindow * >(argp1);
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 (arg1)->Raise();
33944 wxPyEndAllowThreads(__tstate);
33945 if (PyErr_Occurred()) SWIG_fail;
33946 }
33947 resultobj = SWIG_Py_Void();
33948 return resultobj;
33949 fail:
33950 return NULL;
33951 }
33952
33953
33954 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33955 PyObject *resultobj = 0;
33956 wxWindow *arg1 = (wxWindow *) 0 ;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 PyObject *swig_obj[1] ;
33960
33961 if (!args) SWIG_fail;
33962 swig_obj[0] = args;
33963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 (arg1)->Lower();
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_Py_Void();
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 wxWindow *arg1 = (wxWindow *) 0 ;
33984 wxSize *arg2 = 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 wxSize temp2 ;
33988 PyObject * obj0 = 0 ;
33989 PyObject * obj1 = 0 ;
33990 char * kwnames[] = {
33991 (char *) "self",(char *) "size", NULL
33992 };
33993
33994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33998 }
33999 arg1 = reinterpret_cast< wxWindow * >(argp1);
34000 {
34001 arg2 = &temp2;
34002 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 (arg1)->SetClientSize((wxSize const &)*arg2);
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_Py_Void();
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 int arg2 ;
34021 int arg3 ;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 int val2 ;
34025 int ecode2 = 0 ;
34026 int val3 ;
34027 int ecode3 = 0 ;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 PyObject * obj2 = 0 ;
34031 char * kwnames[] = {
34032 (char *) "self",(char *) "width",(char *) "height", NULL
34033 };
34034
34035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34037 if (!SWIG_IsOK(res1)) {
34038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34039 }
34040 arg1 = reinterpret_cast< wxWindow * >(argp1);
34041 ecode2 = SWIG_AsVal_int(obj1, &val2);
34042 if (!SWIG_IsOK(ecode2)) {
34043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34044 }
34045 arg2 = static_cast< int >(val2);
34046 ecode3 = SWIG_AsVal_int(obj2, &val3);
34047 if (!SWIG_IsOK(ecode3)) {
34048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34049 }
34050 arg3 = static_cast< int >(val3);
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 (arg1)->SetClientSize(arg2,arg3);
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 resultobj = SWIG_Py_Void();
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 wxRect *arg2 = 0 ;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 wxRect temp2 ;
34071 PyObject * obj0 = 0 ;
34072 PyObject * obj1 = 0 ;
34073 char * kwnames[] = {
34074 (char *) "self",(char *) "rect", NULL
34075 };
34076
34077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34081 }
34082 arg1 = reinterpret_cast< wxWindow * >(argp1);
34083 {
34084 arg2 = &temp2;
34085 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34086 }
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 (arg1)->SetClientSize((wxRect const &)*arg2);
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 resultobj = SWIG_Py_Void();
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34101 PyObject *resultobj = 0;
34102 wxWindow *arg1 = (wxWindow *) 0 ;
34103 wxPoint result;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 PyObject *swig_obj[1] ;
34107
34108 if (!args) SWIG_fail;
34109 swig_obj[0] = args;
34110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34113 }
34114 arg1 = reinterpret_cast< wxWindow * >(argp1);
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = ((wxWindow const *)arg1)->GetPosition();
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34129 PyObject *resultobj = 0;
34130 wxWindow *arg1 = (wxWindow *) 0 ;
34131 int *arg2 = (int *) 0 ;
34132 int *arg3 = (int *) 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 int temp2 ;
34136 int res2 = SWIG_TMPOBJ ;
34137 int temp3 ;
34138 int res3 = SWIG_TMPOBJ ;
34139 PyObject *swig_obj[1] ;
34140
34141 arg2 = &temp2;
34142 arg3 = &temp3;
34143 if (!args) SWIG_fail;
34144 swig_obj[0] = args;
34145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34146 if (!SWIG_IsOK(res1)) {
34147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34148 }
34149 arg1 = reinterpret_cast< wxWindow * >(argp1);
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_Py_Void();
34157 if (SWIG_IsTmpObj(res2)) {
34158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34159 } else {
34160 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34162 }
34163 if (SWIG_IsTmpObj(res3)) {
34164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34165 } else {
34166 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34168 }
34169 return resultobj;
34170 fail:
34171 return NULL;
34172 }
34173
34174
34175 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34176 PyObject *resultobj = 0;
34177 wxWindow *arg1 = (wxWindow *) 0 ;
34178 wxPoint result;
34179 void *argp1 = 0 ;
34180 int res1 = 0 ;
34181 PyObject *swig_obj[1] ;
34182
34183 if (!args) SWIG_fail;
34184 swig_obj[0] = args;
34185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34186 if (!SWIG_IsOK(res1)) {
34187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34188 }
34189 arg1 = reinterpret_cast< wxWindow * >(argp1);
34190 {
34191 PyThreadState* __tstate = wxPyBeginAllowThreads();
34192 result = ((wxWindow const *)arg1)->GetScreenPosition();
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34204 PyObject *resultobj = 0;
34205 wxWindow *arg1 = (wxWindow *) 0 ;
34206 int *arg2 = (int *) 0 ;
34207 int *arg3 = (int *) 0 ;
34208 void *argp1 = 0 ;
34209 int res1 = 0 ;
34210 int temp2 ;
34211 int res2 = SWIG_TMPOBJ ;
34212 int temp3 ;
34213 int res3 = SWIG_TMPOBJ ;
34214 PyObject *swig_obj[1] ;
34215
34216 arg2 = &temp2;
34217 arg3 = &temp3;
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_Py_Void();
34232 if (SWIG_IsTmpObj(res2)) {
34233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34234 } else {
34235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34237 }
34238 if (SWIG_IsTmpObj(res3)) {
34239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34240 } else {
34241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34243 }
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34251 PyObject *resultobj = 0;
34252 wxWindow *arg1 = (wxWindow *) 0 ;
34253 wxRect result;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 PyObject *swig_obj[1] ;
34257
34258 if (!args) SWIG_fail;
34259 swig_obj[0] = args;
34260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34263 }
34264 arg1 = reinterpret_cast< wxWindow * >(argp1);
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 result = ((wxWindow const *)arg1)->GetScreenRect();
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279 PyObject *resultobj = 0;
34280 wxWindow *arg1 = (wxWindow *) 0 ;
34281 wxSize result;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 PyObject *swig_obj[1] ;
34285
34286 if (!args) SWIG_fail;
34287 swig_obj[0] = args;
34288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34289 if (!SWIG_IsOK(res1)) {
34290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34291 }
34292 arg1 = reinterpret_cast< wxWindow * >(argp1);
34293 {
34294 PyThreadState* __tstate = wxPyBeginAllowThreads();
34295 result = ((wxWindow const *)arg1)->GetSize();
34296 wxPyEndAllowThreads(__tstate);
34297 if (PyErr_Occurred()) SWIG_fail;
34298 }
34299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34300 return resultobj;
34301 fail:
34302 return NULL;
34303 }
34304
34305
34306 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34307 PyObject *resultobj = 0;
34308 wxWindow *arg1 = (wxWindow *) 0 ;
34309 int *arg2 = (int *) 0 ;
34310 int *arg3 = (int *) 0 ;
34311 void *argp1 = 0 ;
34312 int res1 = 0 ;
34313 int temp2 ;
34314 int res2 = SWIG_TMPOBJ ;
34315 int temp3 ;
34316 int res3 = SWIG_TMPOBJ ;
34317 PyObject *swig_obj[1] ;
34318
34319 arg2 = &temp2;
34320 arg3 = &temp3;
34321 if (!args) SWIG_fail;
34322 swig_obj[0] = args;
34323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34324 if (!SWIG_IsOK(res1)) {
34325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34326 }
34327 arg1 = reinterpret_cast< wxWindow * >(argp1);
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 resultobj = SWIG_Py_Void();
34335 if (SWIG_IsTmpObj(res2)) {
34336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34337 } else {
34338 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34340 }
34341 if (SWIG_IsTmpObj(res3)) {
34342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34343 } else {
34344 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34346 }
34347 return resultobj;
34348 fail:
34349 return NULL;
34350 }
34351
34352
34353 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34354 PyObject *resultobj = 0;
34355 wxWindow *arg1 = (wxWindow *) 0 ;
34356 wxRect result;
34357 void *argp1 = 0 ;
34358 int res1 = 0 ;
34359 PyObject *swig_obj[1] ;
34360
34361 if (!args) SWIG_fail;
34362 swig_obj[0] = args;
34363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34364 if (!SWIG_IsOK(res1)) {
34365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34366 }
34367 arg1 = reinterpret_cast< wxWindow * >(argp1);
34368 {
34369 PyThreadState* __tstate = wxPyBeginAllowThreads();
34370 result = ((wxWindow const *)arg1)->GetRect();
34371 wxPyEndAllowThreads(__tstate);
34372 if (PyErr_Occurred()) SWIG_fail;
34373 }
34374 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34375 return resultobj;
34376 fail:
34377 return NULL;
34378 }
34379
34380
34381 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34382 PyObject *resultobj = 0;
34383 wxWindow *arg1 = (wxWindow *) 0 ;
34384 wxSize result;
34385 void *argp1 = 0 ;
34386 int res1 = 0 ;
34387 PyObject *swig_obj[1] ;
34388
34389 if (!args) SWIG_fail;
34390 swig_obj[0] = args;
34391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34392 if (!SWIG_IsOK(res1)) {
34393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34394 }
34395 arg1 = reinterpret_cast< wxWindow * >(argp1);
34396 {
34397 PyThreadState* __tstate = wxPyBeginAllowThreads();
34398 result = ((wxWindow const *)arg1)->GetClientSize();
34399 wxPyEndAllowThreads(__tstate);
34400 if (PyErr_Occurred()) SWIG_fail;
34401 }
34402 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34403 return resultobj;
34404 fail:
34405 return NULL;
34406 }
34407
34408
34409 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34410 PyObject *resultobj = 0;
34411 wxWindow *arg1 = (wxWindow *) 0 ;
34412 int *arg2 = (int *) 0 ;
34413 int *arg3 = (int *) 0 ;
34414 void *argp1 = 0 ;
34415 int res1 = 0 ;
34416 int temp2 ;
34417 int res2 = SWIG_TMPOBJ ;
34418 int temp3 ;
34419 int res3 = SWIG_TMPOBJ ;
34420 PyObject *swig_obj[1] ;
34421
34422 arg2 = &temp2;
34423 arg3 = &temp3;
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34429 }
34430 arg1 = reinterpret_cast< wxWindow * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_Py_Void();
34438 if (SWIG_IsTmpObj(res2)) {
34439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34440 } else {
34441 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34443 }
34444 if (SWIG_IsTmpObj(res3)) {
34445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34446 } else {
34447 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34449 }
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 wxPoint result;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34469 }
34470 arg1 = reinterpret_cast< wxWindow * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34485 PyObject *resultobj = 0;
34486 wxWindow *arg1 = (wxWindow *) 0 ;
34487 wxRect result;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 PyObject *swig_obj[1] ;
34491
34492 if (!args) SWIG_fail;
34493 swig_obj[0] = args;
34494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34495 if (!SWIG_IsOK(res1)) {
34496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34497 }
34498 arg1 = reinterpret_cast< wxWindow * >(argp1);
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 result = ((wxWindow const *)arg1)->GetClientRect();
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34513 PyObject *resultobj = 0;
34514 wxWindow *arg1 = (wxWindow *) 0 ;
34515 wxSize result;
34516 void *argp1 = 0 ;
34517 int res1 = 0 ;
34518 PyObject *swig_obj[1] ;
34519
34520 if (!args) SWIG_fail;
34521 swig_obj[0] = args;
34522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34523 if (!SWIG_IsOK(res1)) {
34524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34525 }
34526 arg1 = reinterpret_cast< wxWindow * >(argp1);
34527 {
34528 PyThreadState* __tstate = wxPyBeginAllowThreads();
34529 result = ((wxWindow const *)arg1)->GetBestSize();
34530 wxPyEndAllowThreads(__tstate);
34531 if (PyErr_Occurred()) SWIG_fail;
34532 }
34533 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34534 return resultobj;
34535 fail:
34536 return NULL;
34537 }
34538
34539
34540 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34541 PyObject *resultobj = 0;
34542 wxWindow *arg1 = (wxWindow *) 0 ;
34543 int *arg2 = (int *) 0 ;
34544 int *arg3 = (int *) 0 ;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 int temp2 ;
34548 int res2 = SWIG_TMPOBJ ;
34549 int temp3 ;
34550 int res3 = SWIG_TMPOBJ ;
34551 PyObject *swig_obj[1] ;
34552
34553 arg2 = &temp2;
34554 arg3 = &temp3;
34555 if (!args) SWIG_fail;
34556 swig_obj[0] = args;
34557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34558 if (!SWIG_IsOK(res1)) {
34559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34560 }
34561 arg1 = reinterpret_cast< wxWindow * >(argp1);
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34565 wxPyEndAllowThreads(__tstate);
34566 if (PyErr_Occurred()) SWIG_fail;
34567 }
34568 resultobj = SWIG_Py_Void();
34569 if (SWIG_IsTmpObj(res2)) {
34570 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34571 } else {
34572 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34574 }
34575 if (SWIG_IsTmpObj(res3)) {
34576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34577 } else {
34578 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34580 }
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34588 PyObject *resultobj = 0;
34589 wxWindow *arg1 = (wxWindow *) 0 ;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 PyObject *swig_obj[1] ;
34593
34594 if (!args) SWIG_fail;
34595 swig_obj[0] = args;
34596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34597 if (!SWIG_IsOK(res1)) {
34598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34599 }
34600 arg1 = reinterpret_cast< wxWindow * >(argp1);
34601 {
34602 PyThreadState* __tstate = wxPyBeginAllowThreads();
34603 (arg1)->InvalidateBestSize();
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 resultobj = SWIG_Py_Void();
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj = 0;
34616 wxWindow *arg1 = (wxWindow *) 0 ;
34617 wxSize *arg2 = 0 ;
34618 void *argp1 = 0 ;
34619 int res1 = 0 ;
34620 wxSize temp2 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 char * kwnames[] = {
34624 (char *) "self",(char *) "size", NULL
34625 };
34626
34627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 {
34634 arg2 = &temp2;
34635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34636 }
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 resultobj = SWIG_Py_Void();
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 wxSize result;
34654 void *argp1 = 0 ;
34655 int res1 = 0 ;
34656 PyObject *swig_obj[1] ;
34657
34658 if (!args) SWIG_fail;
34659 swig_obj[0] = args;
34660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34661 if (!SWIG_IsOK(res1)) {
34662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34663 }
34664 arg1 = reinterpret_cast< wxWindow * >(argp1);
34665 {
34666 PyThreadState* __tstate = wxPyBeginAllowThreads();
34667 result = ((wxWindow const *)arg1)->GetBestFittingSize();
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj = 0;
34680 wxWindow *arg1 = (wxWindow *) 0 ;
34681 int arg2 = (int) wxBOTH ;
34682 void *argp1 = 0 ;
34683 int res1 = 0 ;
34684 int val2 ;
34685 int ecode2 = 0 ;
34686 PyObject * obj0 = 0 ;
34687 PyObject * obj1 = 0 ;
34688 char * kwnames[] = {
34689 (char *) "self",(char *) "direction", NULL
34690 };
34691
34692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34694 if (!SWIG_IsOK(res1)) {
34695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34696 }
34697 arg1 = reinterpret_cast< wxWindow * >(argp1);
34698 if (obj1) {
34699 ecode2 = SWIG_AsVal_int(obj1, &val2);
34700 if (!SWIG_IsOK(ecode2)) {
34701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34702 }
34703 arg2 = static_cast< int >(val2);
34704 }
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 (arg1)->Center(arg2);
34708 wxPyEndAllowThreads(__tstate);
34709 if (PyErr_Occurred()) SWIG_fail;
34710 }
34711 resultobj = SWIG_Py_Void();
34712 return resultobj;
34713 fail:
34714 return NULL;
34715 }
34716
34717
34718 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34719 PyObject *resultobj = 0;
34720 wxWindow *arg1 = (wxWindow *) 0 ;
34721 int arg2 = (int) wxBOTH ;
34722 void *argp1 = 0 ;
34723 int res1 = 0 ;
34724 int val2 ;
34725 int ecode2 = 0 ;
34726 PyObject * obj0 = 0 ;
34727 PyObject * obj1 = 0 ;
34728 char * kwnames[] = {
34729 (char *) "self",(char *) "dir", NULL
34730 };
34731
34732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34736 }
34737 arg1 = reinterpret_cast< wxWindow * >(argp1);
34738 if (obj1) {
34739 ecode2 = SWIG_AsVal_int(obj1, &val2);
34740 if (!SWIG_IsOK(ecode2)) {
34741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34742 }
34743 arg2 = static_cast< int >(val2);
34744 }
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->CenterOnParent(arg2);
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_Py_Void();
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 void *argp1 = 0 ;
34762 int res1 = 0 ;
34763 PyObject *swig_obj[1] ;
34764
34765 if (!args) SWIG_fail;
34766 swig_obj[0] = args;
34767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34768 if (!SWIG_IsOK(res1)) {
34769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34770 }
34771 arg1 = reinterpret_cast< wxWindow * >(argp1);
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 (arg1)->Fit();
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 resultobj = SWIG_Py_Void();
34779 return resultobj;
34780 fail:
34781 return NULL;
34782 }
34783
34784
34785 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34786 PyObject *resultobj = 0;
34787 wxWindow *arg1 = (wxWindow *) 0 ;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 PyObject *swig_obj[1] ;
34791
34792 if (!args) SWIG_fail;
34793 swig_obj[0] = args;
34794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34795 if (!SWIG_IsOK(res1)) {
34796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34797 }
34798 arg1 = reinterpret_cast< wxWindow * >(argp1);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 (arg1)->FitInside();
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 resultobj = SWIG_Py_Void();
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34813 PyObject *resultobj = 0;
34814 wxWindow *arg1 = (wxWindow *) 0 ;
34815 int arg2 ;
34816 int arg3 ;
34817 int arg4 = (int) -1 ;
34818 int arg5 = (int) -1 ;
34819 int arg6 = (int) -1 ;
34820 int arg7 = (int) -1 ;
34821 void *argp1 = 0 ;
34822 int res1 = 0 ;
34823 int val2 ;
34824 int ecode2 = 0 ;
34825 int val3 ;
34826 int ecode3 = 0 ;
34827 int val4 ;
34828 int ecode4 = 0 ;
34829 int val5 ;
34830 int ecode5 = 0 ;
34831 int val6 ;
34832 int ecode6 = 0 ;
34833 int val7 ;
34834 int ecode7 = 0 ;
34835 PyObject * obj0 = 0 ;
34836 PyObject * obj1 = 0 ;
34837 PyObject * obj2 = 0 ;
34838 PyObject * obj3 = 0 ;
34839 PyObject * obj4 = 0 ;
34840 PyObject * obj5 = 0 ;
34841 PyObject * obj6 = 0 ;
34842 char * kwnames[] = {
34843 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34844 };
34845
34846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34850 }
34851 arg1 = reinterpret_cast< wxWindow * >(argp1);
34852 ecode2 = SWIG_AsVal_int(obj1, &val2);
34853 if (!SWIG_IsOK(ecode2)) {
34854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34855 }
34856 arg2 = static_cast< int >(val2);
34857 ecode3 = SWIG_AsVal_int(obj2, &val3);
34858 if (!SWIG_IsOK(ecode3)) {
34859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34860 }
34861 arg3 = static_cast< int >(val3);
34862 if (obj3) {
34863 ecode4 = SWIG_AsVal_int(obj3, &val4);
34864 if (!SWIG_IsOK(ecode4)) {
34865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34866 }
34867 arg4 = static_cast< int >(val4);
34868 }
34869 if (obj4) {
34870 ecode5 = SWIG_AsVal_int(obj4, &val5);
34871 if (!SWIG_IsOK(ecode5)) {
34872 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34873 }
34874 arg5 = static_cast< int >(val5);
34875 }
34876 if (obj5) {
34877 ecode6 = SWIG_AsVal_int(obj5, &val6);
34878 if (!SWIG_IsOK(ecode6)) {
34879 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34880 }
34881 arg6 = static_cast< int >(val6);
34882 }
34883 if (obj6) {
34884 ecode7 = SWIG_AsVal_int(obj6, &val7);
34885 if (!SWIG_IsOK(ecode7)) {
34886 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34887 }
34888 arg7 = static_cast< int >(val7);
34889 }
34890 {
34891 PyThreadState* __tstate = wxPyBeginAllowThreads();
34892 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34893 wxPyEndAllowThreads(__tstate);
34894 if (PyErr_Occurred()) SWIG_fail;
34895 }
34896 resultobj = SWIG_Py_Void();
34897 return resultobj;
34898 fail:
34899 return NULL;
34900 }
34901
34902
34903 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34904 PyObject *resultobj = 0;
34905 wxWindow *arg1 = (wxWindow *) 0 ;
34906 wxSize *arg2 = 0 ;
34907 wxSize const &arg3_defvalue = wxDefaultSize ;
34908 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34909 wxSize const &arg4_defvalue = wxDefaultSize ;
34910 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 wxSize temp2 ;
34914 wxSize temp3 ;
34915 wxSize temp4 ;
34916 PyObject * obj0 = 0 ;
34917 PyObject * obj1 = 0 ;
34918 PyObject * obj2 = 0 ;
34919 PyObject * obj3 = 0 ;
34920 char * kwnames[] = {
34921 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34922 };
34923
34924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34926 if (!SWIG_IsOK(res1)) {
34927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34928 }
34929 arg1 = reinterpret_cast< wxWindow * >(argp1);
34930 {
34931 arg2 = &temp2;
34932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34933 }
34934 if (obj2) {
34935 {
34936 arg3 = &temp3;
34937 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34938 }
34939 }
34940 if (obj3) {
34941 {
34942 arg4 = &temp4;
34943 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34944 }
34945 }
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 resultobj = SWIG_Py_Void();
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34960 PyObject *resultobj = 0;
34961 wxWindow *arg1 = (wxWindow *) 0 ;
34962 int arg2 ;
34963 int arg3 ;
34964 int arg4 = (int) -1 ;
34965 int arg5 = (int) -1 ;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 int val2 ;
34969 int ecode2 = 0 ;
34970 int val3 ;
34971 int ecode3 = 0 ;
34972 int val4 ;
34973 int ecode4 = 0 ;
34974 int val5 ;
34975 int ecode5 = 0 ;
34976 PyObject * obj0 = 0 ;
34977 PyObject * obj1 = 0 ;
34978 PyObject * obj2 = 0 ;
34979 PyObject * obj3 = 0 ;
34980 PyObject * obj4 = 0 ;
34981 char * kwnames[] = {
34982 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34983 };
34984
34985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34987 if (!SWIG_IsOK(res1)) {
34988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34989 }
34990 arg1 = reinterpret_cast< wxWindow * >(argp1);
34991 ecode2 = SWIG_AsVal_int(obj1, &val2);
34992 if (!SWIG_IsOK(ecode2)) {
34993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34994 }
34995 arg2 = static_cast< int >(val2);
34996 ecode3 = SWIG_AsVal_int(obj2, &val3);
34997 if (!SWIG_IsOK(ecode3)) {
34998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34999 }
35000 arg3 = static_cast< int >(val3);
35001 if (obj3) {
35002 ecode4 = SWIG_AsVal_int(obj3, &val4);
35003 if (!SWIG_IsOK(ecode4)) {
35004 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35005 }
35006 arg4 = static_cast< int >(val4);
35007 }
35008 if (obj4) {
35009 ecode5 = SWIG_AsVal_int(obj4, &val5);
35010 if (!SWIG_IsOK(ecode5)) {
35011 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35012 }
35013 arg5 = static_cast< int >(val5);
35014 }
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 resultobj = SWIG_Py_Void();
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxSize *arg2 = 0 ;
35032 wxSize const &arg3_defvalue = wxDefaultSize ;
35033 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 wxSize temp2 ;
35037 wxSize temp3 ;
35038 PyObject * obj0 = 0 ;
35039 PyObject * obj1 = 0 ;
35040 PyObject * obj2 = 0 ;
35041 char * kwnames[] = {
35042 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35043 };
35044
35045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35047 if (!SWIG_IsOK(res1)) {
35048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35049 }
35050 arg1 = reinterpret_cast< wxWindow * >(argp1);
35051 {
35052 arg2 = &temp2;
35053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35054 }
35055 if (obj2) {
35056 {
35057 arg3 = &temp3;
35058 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35059 }
35060 }
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 resultobj = SWIG_Py_Void();
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35075 PyObject *resultobj = 0;
35076 wxWindow *arg1 = (wxWindow *) 0 ;
35077 wxSize result;
35078 void *argp1 = 0 ;
35079 int res1 = 0 ;
35080 PyObject *swig_obj[1] ;
35081
35082 if (!args) SWIG_fail;
35083 swig_obj[0] = args;
35084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35085 if (!SWIG_IsOK(res1)) {
35086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35087 }
35088 arg1 = reinterpret_cast< wxWindow * >(argp1);
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = ((wxWindow const *)arg1)->GetMaxSize();
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35103 PyObject *resultobj = 0;
35104 wxWindow *arg1 = (wxWindow *) 0 ;
35105 wxSize result;
35106 void *argp1 = 0 ;
35107 int res1 = 0 ;
35108 PyObject *swig_obj[1] ;
35109
35110 if (!args) SWIG_fail;
35111 swig_obj[0] = args;
35112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = ((wxWindow const *)arg1)->GetMinSize();
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj = 0;
35132 wxWindow *arg1 = (wxWindow *) 0 ;
35133 wxSize *arg2 = 0 ;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 wxSize temp2 ;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char * kwnames[] = {
35140 (char *) "self",(char *) "minSize", NULL
35141 };
35142
35143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 arg2 = &temp2;
35151 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35152 }
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 (arg1)->SetMinSize((wxSize const &)*arg2);
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_Py_Void();
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj = 0;
35168 wxWindow *arg1 = (wxWindow *) 0 ;
35169 wxSize *arg2 = 0 ;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 wxSize temp2 ;
35173 PyObject * obj0 = 0 ;
35174 PyObject * obj1 = 0 ;
35175 char * kwnames[] = {
35176 (char *) "self",(char *) "maxSize", NULL
35177 };
35178
35179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35183 }
35184 arg1 = reinterpret_cast< wxWindow * >(argp1);
35185 {
35186 arg2 = &temp2;
35187 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35188 }
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 (arg1)->SetMaxSize((wxSize const &)*arg2);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_Py_Void();
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 int result;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 PyObject *swig_obj[1] ;
35209
35210 if (!args) SWIG_fail;
35211 swig_obj[0] = args;
35212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35213 if (!SWIG_IsOK(res1)) {
35214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35215 }
35216 arg1 = reinterpret_cast< wxWindow * >(argp1);
35217 {
35218 PyThreadState* __tstate = wxPyBeginAllowThreads();
35219 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35220 wxPyEndAllowThreads(__tstate);
35221 if (PyErr_Occurred()) SWIG_fail;
35222 }
35223 resultobj = SWIG_From_int(static_cast< int >(result));
35224 return resultobj;
35225 fail:
35226 return NULL;
35227 }
35228
35229
35230 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35231 PyObject *resultobj = 0;
35232 wxWindow *arg1 = (wxWindow *) 0 ;
35233 int result;
35234 void *argp1 = 0 ;
35235 int res1 = 0 ;
35236 PyObject *swig_obj[1] ;
35237
35238 if (!args) SWIG_fail;
35239 swig_obj[0] = args;
35240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35241 if (!SWIG_IsOK(res1)) {
35242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35243 }
35244 arg1 = reinterpret_cast< wxWindow * >(argp1);
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35248 wxPyEndAllowThreads(__tstate);
35249 if (PyErr_Occurred()) SWIG_fail;
35250 }
35251 resultobj = SWIG_From_int(static_cast< int >(result));
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 int result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35271 }
35272 arg1 = reinterpret_cast< wxWindow * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_From_int(static_cast< int >(result));
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 int result;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 PyObject *swig_obj[1] ;
35293
35294 if (!args) SWIG_fail;
35295 swig_obj[0] = args;
35296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35299 }
35300 arg1 = reinterpret_cast< wxWindow * >(argp1);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_From_int(static_cast< int >(result));
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 wxSize *arg2 = 0 ;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 wxSize temp2 ;
35321 PyObject * obj0 = 0 ;
35322 PyObject * obj1 = 0 ;
35323 char * kwnames[] = {
35324 (char *) "self",(char *) "size", NULL
35325 };
35326
35327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35329 if (!SWIG_IsOK(res1)) {
35330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35331 }
35332 arg1 = reinterpret_cast< wxWindow * >(argp1);
35333 {
35334 arg2 = &temp2;
35335 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35336 }
35337 {
35338 PyThreadState* __tstate = wxPyBeginAllowThreads();
35339 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35340 wxPyEndAllowThreads(__tstate);
35341 if (PyErr_Occurred()) SWIG_fail;
35342 }
35343 resultobj = SWIG_Py_Void();
35344 return resultobj;
35345 fail:
35346 return NULL;
35347 }
35348
35349
35350 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35351 PyObject *resultobj = 0;
35352 wxWindow *arg1 = (wxWindow *) 0 ;
35353 int arg2 ;
35354 int arg3 ;
35355 void *argp1 = 0 ;
35356 int res1 = 0 ;
35357 int val2 ;
35358 int ecode2 = 0 ;
35359 int val3 ;
35360 int ecode3 = 0 ;
35361 PyObject * obj0 = 0 ;
35362 PyObject * obj1 = 0 ;
35363 PyObject * obj2 = 0 ;
35364 char * kwnames[] = {
35365 (char *) "self",(char *) "w",(char *) "h", NULL
35366 };
35367
35368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35372 }
35373 arg1 = reinterpret_cast< wxWindow * >(argp1);
35374 ecode2 = SWIG_AsVal_int(obj1, &val2);
35375 if (!SWIG_IsOK(ecode2)) {
35376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35377 }
35378 arg2 = static_cast< int >(val2);
35379 ecode3 = SWIG_AsVal_int(obj2, &val3);
35380 if (!SWIG_IsOK(ecode3)) {
35381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35382 }
35383 arg3 = static_cast< int >(val3);
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 (arg1)->SetVirtualSize(arg2,arg3);
35387 wxPyEndAllowThreads(__tstate);
35388 if (PyErr_Occurred()) SWIG_fail;
35389 }
35390 resultobj = SWIG_Py_Void();
35391 return resultobj;
35392 fail:
35393 return NULL;
35394 }
35395
35396
35397 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35398 PyObject *resultobj = 0;
35399 wxWindow *arg1 = (wxWindow *) 0 ;
35400 wxSize result;
35401 void *argp1 = 0 ;
35402 int res1 = 0 ;
35403 PyObject *swig_obj[1] ;
35404
35405 if (!args) SWIG_fail;
35406 swig_obj[0] = args;
35407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35408 if (!SWIG_IsOK(res1)) {
35409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35410 }
35411 arg1 = reinterpret_cast< wxWindow * >(argp1);
35412 {
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 result = ((wxWindow const *)arg1)->GetVirtualSize();
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35419 return resultobj;
35420 fail:
35421 return NULL;
35422 }
35423
35424
35425 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35426 PyObject *resultobj = 0;
35427 wxWindow *arg1 = (wxWindow *) 0 ;
35428 int *arg2 = (int *) 0 ;
35429 int *arg3 = (int *) 0 ;
35430 void *argp1 = 0 ;
35431 int res1 = 0 ;
35432 int temp2 ;
35433 int res2 = SWIG_TMPOBJ ;
35434 int temp3 ;
35435 int res3 = SWIG_TMPOBJ ;
35436 PyObject *swig_obj[1] ;
35437
35438 arg2 = &temp2;
35439 arg3 = &temp3;
35440 if (!args) SWIG_fail;
35441 swig_obj[0] = args;
35442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 resultobj = SWIG_Py_Void();
35454 if (SWIG_IsTmpObj(res2)) {
35455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35456 } else {
35457 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35459 }
35460 if (SWIG_IsTmpObj(res3)) {
35461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35462 } else {
35463 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35465 }
35466 return resultobj;
35467 fail:
35468 return NULL;
35469 }
35470
35471
35472 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35473 PyObject *resultobj = 0;
35474 wxWindow *arg1 = (wxWindow *) 0 ;
35475 wxSize result;
35476 void *argp1 = 0 ;
35477 int res1 = 0 ;
35478 PyObject *swig_obj[1] ;
35479
35480 if (!args) SWIG_fail;
35481 swig_obj[0] = args;
35482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35483 if (!SWIG_IsOK(res1)) {
35484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35485 }
35486 arg1 = reinterpret_cast< wxWindow * >(argp1);
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35494 return resultobj;
35495 fail:
35496 return NULL;
35497 }
35498
35499
35500 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = 0;
35502 wxWindow *arg1 = (wxWindow *) 0 ;
35503 bool arg2 = (bool) true ;
35504 bool result;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 bool val2 ;
35508 int ecode2 = 0 ;
35509 PyObject * obj0 = 0 ;
35510 PyObject * obj1 = 0 ;
35511 char * kwnames[] = {
35512 (char *) "self",(char *) "show", NULL
35513 };
35514
35515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35519 }
35520 arg1 = reinterpret_cast< wxWindow * >(argp1);
35521 if (obj1) {
35522 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35523 if (!SWIG_IsOK(ecode2)) {
35524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35525 }
35526 arg2 = static_cast< bool >(val2);
35527 }
35528 {
35529 PyThreadState* __tstate = wxPyBeginAllowThreads();
35530 result = (bool)(arg1)->Show(arg2);
35531 wxPyEndAllowThreads(__tstate);
35532 if (PyErr_Occurred()) SWIG_fail;
35533 }
35534 {
35535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35536 }
35537 return resultobj;
35538 fail:
35539 return NULL;
35540 }
35541
35542
35543 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35544 PyObject *resultobj = 0;
35545 wxWindow *arg1 = (wxWindow *) 0 ;
35546 bool result;
35547 void *argp1 = 0 ;
35548 int res1 = 0 ;
35549 PyObject *swig_obj[1] ;
35550
35551 if (!args) SWIG_fail;
35552 swig_obj[0] = args;
35553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35556 }
35557 arg1 = reinterpret_cast< wxWindow * >(argp1);
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 result = (bool)(arg1)->Hide();
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 {
35565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = 0;
35575 wxWindow *arg1 = (wxWindow *) 0 ;
35576 bool arg2 = (bool) true ;
35577 bool result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 bool val2 ;
35581 int ecode2 = 0 ;
35582 PyObject * obj0 = 0 ;
35583 PyObject * obj1 = 0 ;
35584 char * kwnames[] = {
35585 (char *) "self",(char *) "enable", NULL
35586 };
35587
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 if (obj1) {
35595 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35596 if (!SWIG_IsOK(ecode2)) {
35597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35598 }
35599 arg2 = static_cast< bool >(val2);
35600 }
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 result = (bool)(arg1)->Enable(arg2);
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 {
35608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35609 }
35610 return resultobj;
35611 fail:
35612 return NULL;
35613 }
35614
35615
35616 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35617 PyObject *resultobj = 0;
35618 wxWindow *arg1 = (wxWindow *) 0 ;
35619 bool result;
35620 void *argp1 = 0 ;
35621 int res1 = 0 ;
35622 PyObject *swig_obj[1] ;
35623
35624 if (!args) SWIG_fail;
35625 swig_obj[0] = args;
35626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35627 if (!SWIG_IsOK(res1)) {
35628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35629 }
35630 arg1 = reinterpret_cast< wxWindow * >(argp1);
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 result = (bool)(arg1)->Disable();
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 {
35638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35639 }
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *resultobj = 0;
35648 wxWindow *arg1 = (wxWindow *) 0 ;
35649 bool result;
35650 void *argp1 = 0 ;
35651 int res1 = 0 ;
35652 PyObject *swig_obj[1] ;
35653
35654 if (!args) SWIG_fail;
35655 swig_obj[0] = args;
35656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 PyThreadState* __tstate = wxPyBeginAllowThreads();
35663 result = (bool)((wxWindow const *)arg1)->IsShown();
35664 wxPyEndAllowThreads(__tstate);
35665 if (PyErr_Occurred()) SWIG_fail;
35666 }
35667 {
35668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35669 }
35670 return resultobj;
35671 fail:
35672 return NULL;
35673 }
35674
35675
35676 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35677 PyObject *resultobj = 0;
35678 wxWindow *arg1 = (wxWindow *) 0 ;
35679 bool result;
35680 void *argp1 = 0 ;
35681 int res1 = 0 ;
35682 PyObject *swig_obj[1] ;
35683
35684 if (!args) SWIG_fail;
35685 swig_obj[0] = args;
35686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35687 if (!SWIG_IsOK(res1)) {
35688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35689 }
35690 arg1 = reinterpret_cast< wxWindow * >(argp1);
35691 {
35692 PyThreadState* __tstate = wxPyBeginAllowThreads();
35693 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35694 wxPyEndAllowThreads(__tstate);
35695 if (PyErr_Occurred()) SWIG_fail;
35696 }
35697 {
35698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35699 }
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35707 PyObject *resultobj = 0;
35708 wxWindow *arg1 = (wxWindow *) 0 ;
35709 bool result;
35710 void *argp1 = 0 ;
35711 int res1 = 0 ;
35712 PyObject *swig_obj[1] ;
35713
35714 if (!args) SWIG_fail;
35715 swig_obj[0] = args;
35716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35724 wxPyEndAllowThreads(__tstate);
35725 if (PyErr_Occurred()) SWIG_fail;
35726 }
35727 {
35728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35729 }
35730 return resultobj;
35731 fail:
35732 return NULL;
35733 }
35734
35735
35736 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35737 PyObject *resultobj = 0;
35738 wxWindow *arg1 = (wxWindow *) 0 ;
35739 long arg2 ;
35740 void *argp1 = 0 ;
35741 int res1 = 0 ;
35742 long val2 ;
35743 int ecode2 = 0 ;
35744 PyObject * obj0 = 0 ;
35745 PyObject * obj1 = 0 ;
35746 char * kwnames[] = {
35747 (char *) "self",(char *) "style", NULL
35748 };
35749
35750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35752 if (!SWIG_IsOK(res1)) {
35753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35754 }
35755 arg1 = reinterpret_cast< wxWindow * >(argp1);
35756 ecode2 = SWIG_AsVal_long(obj1, &val2);
35757 if (!SWIG_IsOK(ecode2)) {
35758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35759 }
35760 arg2 = static_cast< long >(val2);
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 (arg1)->SetWindowStyleFlag(arg2);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 resultobj = SWIG_Py_Void();
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35775 PyObject *resultobj = 0;
35776 wxWindow *arg1 = (wxWindow *) 0 ;
35777 long result;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject *swig_obj[1] ;
35781
35782 if (!args) SWIG_fail;
35783 swig_obj[0] = args;
35784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35787 }
35788 arg1 = reinterpret_cast< wxWindow * >(argp1);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 resultobj = SWIG_From_long(static_cast< long >(result));
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35803 PyObject *resultobj = 0;
35804 wxWindow *arg1 = (wxWindow *) 0 ;
35805 int arg2 ;
35806 bool result;
35807 void *argp1 = 0 ;
35808 int res1 = 0 ;
35809 int val2 ;
35810 int ecode2 = 0 ;
35811 PyObject * obj0 = 0 ;
35812 PyObject * obj1 = 0 ;
35813 char * kwnames[] = {
35814 (char *) "self",(char *) "flag", NULL
35815 };
35816
35817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35819 if (!SWIG_IsOK(res1)) {
35820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35821 }
35822 arg1 = reinterpret_cast< wxWindow * >(argp1);
35823 ecode2 = SWIG_AsVal_int(obj1, &val2);
35824 if (!SWIG_IsOK(ecode2)) {
35825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35826 }
35827 arg2 = static_cast< int >(val2);
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35831 wxPyEndAllowThreads(__tstate);
35832 if (PyErr_Occurred()) SWIG_fail;
35833 }
35834 {
35835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35836 }
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35844 PyObject *resultobj = 0;
35845 wxWindow *arg1 = (wxWindow *) 0 ;
35846 bool result;
35847 void *argp1 = 0 ;
35848 int res1 = 0 ;
35849 PyObject *swig_obj[1] ;
35850
35851 if (!args) SWIG_fail;
35852 swig_obj[0] = args;
35853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35856 }
35857 arg1 = reinterpret_cast< wxWindow * >(argp1);
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (bool)((wxWindow const *)arg1)->IsRetained();
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 {
35865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35866 }
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 long arg2 ;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 long val2 ;
35880 int ecode2 = 0 ;
35881 PyObject * obj0 = 0 ;
35882 PyObject * obj1 = 0 ;
35883 char * kwnames[] = {
35884 (char *) "self",(char *) "exStyle", NULL
35885 };
35886
35887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35889 if (!SWIG_IsOK(res1)) {
35890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35891 }
35892 arg1 = reinterpret_cast< wxWindow * >(argp1);
35893 ecode2 = SWIG_AsVal_long(obj1, &val2);
35894 if (!SWIG_IsOK(ecode2)) {
35895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35896 }
35897 arg2 = static_cast< long >(val2);
35898 {
35899 PyThreadState* __tstate = wxPyBeginAllowThreads();
35900 (arg1)->SetExtraStyle(arg2);
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 resultobj = SWIG_Py_Void();
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35912 PyObject *resultobj = 0;
35913 wxWindow *arg1 = (wxWindow *) 0 ;
35914 long result;
35915 void *argp1 = 0 ;
35916 int res1 = 0 ;
35917 PyObject *swig_obj[1] ;
35918
35919 if (!args) SWIG_fail;
35920 swig_obj[0] = args;
35921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35922 if (!SWIG_IsOK(res1)) {
35923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35924 }
35925 arg1 = reinterpret_cast< wxWindow * >(argp1);
35926 {
35927 PyThreadState* __tstate = wxPyBeginAllowThreads();
35928 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35929 wxPyEndAllowThreads(__tstate);
35930 if (PyErr_Occurred()) SWIG_fail;
35931 }
35932 resultobj = SWIG_From_long(static_cast< long >(result));
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35940 PyObject *resultobj = 0;
35941 wxWindow *arg1 = (wxWindow *) 0 ;
35942 bool arg2 = (bool) true ;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 bool val2 ;
35946 int ecode2 = 0 ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 char * kwnames[] = {
35950 (char *) "self",(char *) "modal", NULL
35951 };
35952
35953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35955 if (!SWIG_IsOK(res1)) {
35956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35957 }
35958 arg1 = reinterpret_cast< wxWindow * >(argp1);
35959 if (obj1) {
35960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35961 if (!SWIG_IsOK(ecode2)) {
35962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35963 }
35964 arg2 = static_cast< bool >(val2);
35965 }
35966 {
35967 PyThreadState* __tstate = wxPyBeginAllowThreads();
35968 (arg1)->MakeModal(arg2);
35969 wxPyEndAllowThreads(__tstate);
35970 if (PyErr_Occurred()) SWIG_fail;
35971 }
35972 resultobj = SWIG_Py_Void();
35973 return resultobj;
35974 fail:
35975 return NULL;
35976 }
35977
35978
35979 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35980 PyObject *resultobj = 0;
35981 wxWindow *arg1 = (wxWindow *) 0 ;
35982 bool arg2 ;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 bool val2 ;
35986 int ecode2 = 0 ;
35987 PyObject * obj0 = 0 ;
35988 PyObject * obj1 = 0 ;
35989 char * kwnames[] = {
35990 (char *) "self",(char *) "enableTheme", NULL
35991 };
35992
35993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35995 if (!SWIG_IsOK(res1)) {
35996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35997 }
35998 arg1 = reinterpret_cast< wxWindow * >(argp1);
35999 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36000 if (!SWIG_IsOK(ecode2)) {
36001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36002 }
36003 arg2 = static_cast< bool >(val2);
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 (arg1)->SetThemeEnabled(arg2);
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 resultobj = SWIG_Py_Void();
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36018 PyObject *resultobj = 0;
36019 wxWindow *arg1 = (wxWindow *) 0 ;
36020 bool result;
36021 void *argp1 = 0 ;
36022 int res1 = 0 ;
36023 PyObject *swig_obj[1] ;
36024
36025 if (!args) SWIG_fail;
36026 swig_obj[0] = args;
36027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 {
36039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36040 }
36041 return resultobj;
36042 fail:
36043 return NULL;
36044 }
36045
36046
36047 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36048 PyObject *resultobj = 0;
36049 wxWindow *arg1 = (wxWindow *) 0 ;
36050 void *argp1 = 0 ;
36051 int res1 = 0 ;
36052 PyObject *swig_obj[1] ;
36053
36054 if (!args) SWIG_fail;
36055 swig_obj[0] = args;
36056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36059 }
36060 arg1 = reinterpret_cast< wxWindow * >(argp1);
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 (arg1)->SetFocus();
36064 wxPyEndAllowThreads(__tstate);
36065 if (PyErr_Occurred()) SWIG_fail;
36066 }
36067 resultobj = SWIG_Py_Void();
36068 return resultobj;
36069 fail:
36070 return NULL;
36071 }
36072
36073
36074 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36075 PyObject *resultobj = 0;
36076 wxWindow *arg1 = (wxWindow *) 0 ;
36077 void *argp1 = 0 ;
36078 int res1 = 0 ;
36079 PyObject *swig_obj[1] ;
36080
36081 if (!args) SWIG_fail;
36082 swig_obj[0] = args;
36083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36084 if (!SWIG_IsOK(res1)) {
36085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36086 }
36087 arg1 = reinterpret_cast< wxWindow * >(argp1);
36088 {
36089 PyThreadState* __tstate = wxPyBeginAllowThreads();
36090 (arg1)->SetFocusFromKbd();
36091 wxPyEndAllowThreads(__tstate);
36092 if (PyErr_Occurred()) SWIG_fail;
36093 }
36094 resultobj = SWIG_Py_Void();
36095 return resultobj;
36096 fail:
36097 return NULL;
36098 }
36099
36100
36101 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36102 PyObject *resultobj = 0;
36103 wxWindow *result = 0 ;
36104
36105 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36106 {
36107 if (!wxPyCheckForApp()) SWIG_fail;
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 result = (wxWindow *)wxWindow::FindFocus();
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 {
36114 resultobj = wxPyMake_wxObject(result, 0);
36115 }
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36123 PyObject *resultobj = 0;
36124 wxWindow *arg1 = (wxWindow *) 0 ;
36125 bool result;
36126 void *argp1 = 0 ;
36127 int res1 = 0 ;
36128 PyObject *swig_obj[1] ;
36129
36130 if (!args) SWIG_fail;
36131 swig_obj[0] = args;
36132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 {
36144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36145 }
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36153 PyObject *resultobj = 0;
36154 wxWindow *arg1 = (wxWindow *) 0 ;
36155 bool result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 PyObject *swig_obj[1] ;
36159
36160 if (!args) SWIG_fail;
36161 swig_obj[0] = args;
36162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36163 if (!SWIG_IsOK(res1)) {
36164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36165 }
36166 arg1 = reinterpret_cast< wxWindow * >(argp1);
36167 {
36168 PyThreadState* __tstate = wxPyBeginAllowThreads();
36169 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36170 wxPyEndAllowThreads(__tstate);
36171 if (PyErr_Occurred()) SWIG_fail;
36172 }
36173 {
36174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36175 }
36176 return resultobj;
36177 fail:
36178 return NULL;
36179 }
36180
36181
36182 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36183 PyObject *resultobj = 0;
36184 wxWindow *arg1 = (wxWindow *) 0 ;
36185 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36186 bool result;
36187 void *argp1 = 0 ;
36188 int res1 = 0 ;
36189 int val2 ;
36190 int ecode2 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "flags", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 if (obj1) {
36204 ecode2 = SWIG_AsVal_int(obj1, &val2);
36205 if (!SWIG_IsOK(ecode2)) {
36206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36207 }
36208 arg2 = static_cast< int >(val2);
36209 }
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (bool)(arg1)->Navigate(arg2);
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 {
36217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36218 }
36219 return resultobj;
36220 fail:
36221 return NULL;
36222 }
36223
36224
36225 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36226 PyObject *resultobj = 0;
36227 wxWindow *arg1 = (wxWindow *) 0 ;
36228 wxWindow *arg2 = (wxWindow *) 0 ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 void *argp2 = 0 ;
36232 int res2 = 0 ;
36233 PyObject * obj0 = 0 ;
36234 PyObject * obj1 = 0 ;
36235 char * kwnames[] = {
36236 (char *) "self",(char *) "win", NULL
36237 };
36238
36239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36241 if (!SWIG_IsOK(res1)) {
36242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36243 }
36244 arg1 = reinterpret_cast< wxWindow * >(argp1);
36245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36246 if (!SWIG_IsOK(res2)) {
36247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36248 }
36249 arg2 = reinterpret_cast< wxWindow * >(argp2);
36250 {
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 (arg1)->MoveAfterInTabOrder(arg2);
36253 wxPyEndAllowThreads(__tstate);
36254 if (PyErr_Occurred()) SWIG_fail;
36255 }
36256 resultobj = SWIG_Py_Void();
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36264 PyObject *resultobj = 0;
36265 wxWindow *arg1 = (wxWindow *) 0 ;
36266 wxWindow *arg2 = (wxWindow *) 0 ;
36267 void *argp1 = 0 ;
36268 int res1 = 0 ;
36269 void *argp2 = 0 ;
36270 int res2 = 0 ;
36271 PyObject * obj0 = 0 ;
36272 PyObject * obj1 = 0 ;
36273 char * kwnames[] = {
36274 (char *) "self",(char *) "win", NULL
36275 };
36276
36277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36279 if (!SWIG_IsOK(res1)) {
36280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36281 }
36282 arg1 = reinterpret_cast< wxWindow * >(argp1);
36283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36284 if (!SWIG_IsOK(res2)) {
36285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36286 }
36287 arg2 = reinterpret_cast< wxWindow * >(argp2);
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 (arg1)->MoveBeforeInTabOrder(arg2);
36291 wxPyEndAllowThreads(__tstate);
36292 if (PyErr_Occurred()) SWIG_fail;
36293 }
36294 resultobj = SWIG_Py_Void();
36295 return resultobj;
36296 fail:
36297 return NULL;
36298 }
36299
36300
36301 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36302 PyObject *resultobj = 0;
36303 wxWindow *arg1 = (wxWindow *) 0 ;
36304 PyObject *result = 0 ;
36305 void *argp1 = 0 ;
36306 int res1 = 0 ;
36307 PyObject *swig_obj[1] ;
36308
36309 if (!args) SWIG_fail;
36310 swig_obj[0] = args;
36311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36312 if (!SWIG_IsOK(res1)) {
36313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36314 }
36315 arg1 = reinterpret_cast< wxWindow * >(argp1);
36316 {
36317 PyThreadState* __tstate = wxPyBeginAllowThreads();
36318 result = (PyObject *)wxWindow_GetChildren(arg1);
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 resultobj = result;
36323 return resultobj;
36324 fail:
36325 return NULL;
36326 }
36327
36328
36329 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36330 PyObject *resultobj = 0;
36331 wxWindow *arg1 = (wxWindow *) 0 ;
36332 wxWindow *result = 0 ;
36333 void *argp1 = 0 ;
36334 int res1 = 0 ;
36335 PyObject *swig_obj[1] ;
36336
36337 if (!args) SWIG_fail;
36338 swig_obj[0] = args;
36339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36340 if (!SWIG_IsOK(res1)) {
36341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36342 }
36343 arg1 = reinterpret_cast< wxWindow * >(argp1);
36344 {
36345 PyThreadState* __tstate = wxPyBeginAllowThreads();
36346 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36347 wxPyEndAllowThreads(__tstate);
36348 if (PyErr_Occurred()) SWIG_fail;
36349 }
36350 {
36351 resultobj = wxPyMake_wxObject(result, 0);
36352 }
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36360 PyObject *resultobj = 0;
36361 wxWindow *arg1 = (wxWindow *) 0 ;
36362 wxWindow *result = 0 ;
36363 void *argp1 = 0 ;
36364 int res1 = 0 ;
36365 PyObject *swig_obj[1] ;
36366
36367 if (!args) SWIG_fail;
36368 swig_obj[0] = args;
36369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36370 if (!SWIG_IsOK(res1)) {
36371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36372 }
36373 arg1 = reinterpret_cast< wxWindow * >(argp1);
36374 {
36375 PyThreadState* __tstate = wxPyBeginAllowThreads();
36376 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36377 wxPyEndAllowThreads(__tstate);
36378 if (PyErr_Occurred()) SWIG_fail;
36379 }
36380 {
36381 resultobj = wxPyMake_wxObject(result, 0);
36382 }
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36390 PyObject *resultobj = 0;
36391 wxWindow *arg1 = (wxWindow *) 0 ;
36392 bool result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 PyObject *swig_obj[1] ;
36396
36397 if (!args) SWIG_fail;
36398 swig_obj[0] = args;
36399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36402 }
36403 arg1 = reinterpret_cast< wxWindow * >(argp1);
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 {
36411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36412 }
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36420 PyObject *resultobj = 0;
36421 wxWindow *arg1 = (wxWindow *) 0 ;
36422 wxWindow *arg2 = (wxWindow *) 0 ;
36423 bool result;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 void *argp2 = 0 ;
36427 int res2 = 0 ;
36428 PyObject * obj0 = 0 ;
36429 PyObject * obj1 = 0 ;
36430 char * kwnames[] = {
36431 (char *) "self",(char *) "newParent", NULL
36432 };
36433
36434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36436 if (!SWIG_IsOK(res1)) {
36437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36438 }
36439 arg1 = reinterpret_cast< wxWindow * >(argp1);
36440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36441 if (!SWIG_IsOK(res2)) {
36442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36443 }
36444 arg2 = reinterpret_cast< wxWindow * >(argp2);
36445 {
36446 PyThreadState* __tstate = wxPyBeginAllowThreads();
36447 result = (bool)(arg1)->Reparent(arg2);
36448 wxPyEndAllowThreads(__tstate);
36449 if (PyErr_Occurred()) SWIG_fail;
36450 }
36451 {
36452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36453 }
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36461 PyObject *resultobj = 0;
36462 wxWindow *arg1 = (wxWindow *) 0 ;
36463 wxWindow *arg2 = (wxWindow *) 0 ;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 void *argp2 = 0 ;
36467 int res2 = 0 ;
36468 PyObject * obj0 = 0 ;
36469 PyObject * obj1 = 0 ;
36470 char * kwnames[] = {
36471 (char *) "self",(char *) "child", NULL
36472 };
36473
36474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36476 if (!SWIG_IsOK(res1)) {
36477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36478 }
36479 arg1 = reinterpret_cast< wxWindow * >(argp1);
36480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36481 if (!SWIG_IsOK(res2)) {
36482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36483 }
36484 arg2 = reinterpret_cast< wxWindow * >(argp2);
36485 {
36486 PyThreadState* __tstate = wxPyBeginAllowThreads();
36487 (arg1)->AddChild(arg2);
36488 wxPyEndAllowThreads(__tstate);
36489 if (PyErr_Occurred()) SWIG_fail;
36490 }
36491 resultobj = SWIG_Py_Void();
36492 return resultobj;
36493 fail:
36494 return NULL;
36495 }
36496
36497
36498 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36499 PyObject *resultobj = 0;
36500 wxWindow *arg1 = (wxWindow *) 0 ;
36501 wxWindow *arg2 = (wxWindow *) 0 ;
36502 void *argp1 = 0 ;
36503 int res1 = 0 ;
36504 void *argp2 = 0 ;
36505 int res2 = 0 ;
36506 PyObject * obj0 = 0 ;
36507 PyObject * obj1 = 0 ;
36508 char * kwnames[] = {
36509 (char *) "self",(char *) "child", NULL
36510 };
36511
36512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36514 if (!SWIG_IsOK(res1)) {
36515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36516 }
36517 arg1 = reinterpret_cast< wxWindow * >(argp1);
36518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36519 if (!SWIG_IsOK(res2)) {
36520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36521 }
36522 arg2 = reinterpret_cast< wxWindow * >(argp2);
36523 {
36524 PyThreadState* __tstate = wxPyBeginAllowThreads();
36525 (arg1)->RemoveChild(arg2);
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 resultobj = SWIG_Py_Void();
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36537 PyObject *resultobj = 0;
36538 wxWindow *arg1 = (wxWindow *) 0 ;
36539 bool arg2 ;
36540 void *argp1 = 0 ;
36541 int res1 = 0 ;
36542 bool val2 ;
36543 int ecode2 = 0 ;
36544 PyObject * obj0 = 0 ;
36545 PyObject * obj1 = 0 ;
36546 char * kwnames[] = {
36547 (char *) "self",(char *) "on", NULL
36548 };
36549
36550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36552 if (!SWIG_IsOK(res1)) {
36553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36554 }
36555 arg1 = reinterpret_cast< wxWindow * >(argp1);
36556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36557 if (!SWIG_IsOK(ecode2)) {
36558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36559 }
36560 arg2 = static_cast< bool >(val2);
36561 {
36562 PyThreadState* __tstate = wxPyBeginAllowThreads();
36563 (arg1)->SetDoubleBuffered(arg2);
36564 wxPyEndAllowThreads(__tstate);
36565 if (PyErr_Occurred()) SWIG_fail;
36566 }
36567 resultobj = SWIG_Py_Void();
36568 return resultobj;
36569 fail:
36570 return NULL;
36571 }
36572
36573
36574 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36575 PyObject *resultobj = 0;
36576 wxWindow *arg1 = (wxWindow *) 0 ;
36577 long arg2 ;
36578 wxWindow *result = 0 ;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 long val2 ;
36582 int ecode2 = 0 ;
36583 PyObject * obj0 = 0 ;
36584 PyObject * obj1 = 0 ;
36585 char * kwnames[] = {
36586 (char *) "self",(char *) "winid", NULL
36587 };
36588
36589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 ecode2 = SWIG_AsVal_long(obj1, &val2);
36596 if (!SWIG_IsOK(ecode2)) {
36597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36598 }
36599 arg2 = static_cast< long >(val2);
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 result = (wxWindow *)(arg1)->FindWindow(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 {
36607 resultobj = wxPyMake_wxObject(result, 0);
36608 }
36609 return resultobj;
36610 fail:
36611 return NULL;
36612 }
36613
36614
36615 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36616 PyObject *resultobj = 0;
36617 wxWindow *arg1 = (wxWindow *) 0 ;
36618 wxString *arg2 = 0 ;
36619 wxWindow *result = 0 ;
36620 void *argp1 = 0 ;
36621 int res1 = 0 ;
36622 bool temp2 = false ;
36623 PyObject * obj0 = 0 ;
36624 PyObject * obj1 = 0 ;
36625 char * kwnames[] = {
36626 (char *) "self",(char *) "name", NULL
36627 };
36628
36629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36631 if (!SWIG_IsOK(res1)) {
36632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36633 }
36634 arg1 = reinterpret_cast< wxWindow * >(argp1);
36635 {
36636 arg2 = wxString_in_helper(obj1);
36637 if (arg2 == NULL) SWIG_fail;
36638 temp2 = true;
36639 }
36640 {
36641 PyThreadState* __tstate = wxPyBeginAllowThreads();
36642 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36643 wxPyEndAllowThreads(__tstate);
36644 if (PyErr_Occurred()) SWIG_fail;
36645 }
36646 {
36647 resultobj = wxPyMake_wxObject(result, 0);
36648 }
36649 {
36650 if (temp2)
36651 delete arg2;
36652 }
36653 return resultobj;
36654 fail:
36655 {
36656 if (temp2)
36657 delete arg2;
36658 }
36659 return NULL;
36660 }
36661
36662
36663 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36664 PyObject *resultobj = 0;
36665 wxWindow *arg1 = (wxWindow *) 0 ;
36666 wxEvtHandler *result = 0 ;
36667 void *argp1 = 0 ;
36668 int res1 = 0 ;
36669 PyObject *swig_obj[1] ;
36670
36671 if (!args) SWIG_fail;
36672 swig_obj[0] = args;
36673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36674 if (!SWIG_IsOK(res1)) {
36675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36676 }
36677 arg1 = reinterpret_cast< wxWindow * >(argp1);
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 {
36685 resultobj = wxPyMake_wxObject(result, 0);
36686 }
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj = 0;
36695 wxWindow *arg1 = (wxWindow *) 0 ;
36696 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36697 void *argp1 = 0 ;
36698 int res1 = 0 ;
36699 void *argp2 = 0 ;
36700 int res2 = 0 ;
36701 PyObject * obj0 = 0 ;
36702 PyObject * obj1 = 0 ;
36703 char * kwnames[] = {
36704 (char *) "self",(char *) "handler", NULL
36705 };
36706
36707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36709 if (!SWIG_IsOK(res1)) {
36710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36711 }
36712 arg1 = reinterpret_cast< wxWindow * >(argp1);
36713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36714 if (!SWIG_IsOK(res2)) {
36715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36716 }
36717 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36718 {
36719 PyThreadState* __tstate = wxPyBeginAllowThreads();
36720 (arg1)->SetEventHandler(arg2);
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 resultobj = SWIG_Py_Void();
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj = 0;
36733 wxWindow *arg1 = (wxWindow *) 0 ;
36734 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36735 void *argp1 = 0 ;
36736 int res1 = 0 ;
36737 void *argp2 = 0 ;
36738 int res2 = 0 ;
36739 PyObject * obj0 = 0 ;
36740 PyObject * obj1 = 0 ;
36741 char * kwnames[] = {
36742 (char *) "self",(char *) "handler", NULL
36743 };
36744
36745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36747 if (!SWIG_IsOK(res1)) {
36748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36749 }
36750 arg1 = reinterpret_cast< wxWindow * >(argp1);
36751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36752 if (!SWIG_IsOK(res2)) {
36753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36754 }
36755 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36756 {
36757 PyThreadState* __tstate = wxPyBeginAllowThreads();
36758 (arg1)->PushEventHandler(arg2);
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 resultobj = SWIG_Py_Void();
36763 return resultobj;
36764 fail:
36765 return NULL;
36766 }
36767
36768
36769 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36770 PyObject *resultobj = 0;
36771 wxWindow *arg1 = (wxWindow *) 0 ;
36772 bool arg2 = (bool) false ;
36773 wxEvtHandler *result = 0 ;
36774 void *argp1 = 0 ;
36775 int res1 = 0 ;
36776 bool val2 ;
36777 int ecode2 = 0 ;
36778 PyObject * obj0 = 0 ;
36779 PyObject * obj1 = 0 ;
36780 char * kwnames[] = {
36781 (char *) "self",(char *) "deleteHandler", NULL
36782 };
36783
36784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36786 if (!SWIG_IsOK(res1)) {
36787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36788 }
36789 arg1 = reinterpret_cast< wxWindow * >(argp1);
36790 if (obj1) {
36791 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36792 if (!SWIG_IsOK(ecode2)) {
36793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36794 }
36795 arg2 = static_cast< bool >(val2);
36796 }
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36800 wxPyEndAllowThreads(__tstate);
36801 if (PyErr_Occurred()) SWIG_fail;
36802 }
36803 {
36804 resultobj = wxPyMake_wxObject(result, 0);
36805 }
36806 return resultobj;
36807 fail:
36808 return NULL;
36809 }
36810
36811
36812 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36813 PyObject *resultobj = 0;
36814 wxWindow *arg1 = (wxWindow *) 0 ;
36815 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36816 bool result;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 void *argp2 = 0 ;
36820 int res2 = 0 ;
36821 PyObject * obj0 = 0 ;
36822 PyObject * obj1 = 0 ;
36823 char * kwnames[] = {
36824 (char *) "self",(char *) "handler", NULL
36825 };
36826
36827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36829 if (!SWIG_IsOK(res1)) {
36830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36831 }
36832 arg1 = reinterpret_cast< wxWindow * >(argp1);
36833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36834 if (!SWIG_IsOK(res2)) {
36835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36836 }
36837 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36838 {
36839 PyThreadState* __tstate = wxPyBeginAllowThreads();
36840 result = (bool)(arg1)->RemoveEventHandler(arg2);
36841 wxPyEndAllowThreads(__tstate);
36842 if (PyErr_Occurred()) SWIG_fail;
36843 }
36844 {
36845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36846 }
36847 return resultobj;
36848 fail:
36849 return NULL;
36850 }
36851
36852
36853 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36854 PyObject *resultobj = 0;
36855 wxWindow *arg1 = (wxWindow *) 0 ;
36856 wxValidator *arg2 = 0 ;
36857 void *argp1 = 0 ;
36858 int res1 = 0 ;
36859 void *argp2 = 0 ;
36860 int res2 = 0 ;
36861 PyObject * obj0 = 0 ;
36862 PyObject * obj1 = 0 ;
36863 char * kwnames[] = {
36864 (char *) "self",(char *) "validator", NULL
36865 };
36866
36867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36869 if (!SWIG_IsOK(res1)) {
36870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36871 }
36872 arg1 = reinterpret_cast< wxWindow * >(argp1);
36873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36874 if (!SWIG_IsOK(res2)) {
36875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36876 }
36877 if (!argp2) {
36878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36879 }
36880 arg2 = reinterpret_cast< wxValidator * >(argp2);
36881 {
36882 PyThreadState* __tstate = wxPyBeginAllowThreads();
36883 (arg1)->SetValidator((wxValidator const &)*arg2);
36884 wxPyEndAllowThreads(__tstate);
36885 if (PyErr_Occurred()) SWIG_fail;
36886 }
36887 resultobj = SWIG_Py_Void();
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36895 PyObject *resultobj = 0;
36896 wxWindow *arg1 = (wxWindow *) 0 ;
36897 wxValidator *result = 0 ;
36898 void *argp1 = 0 ;
36899 int res1 = 0 ;
36900 PyObject *swig_obj[1] ;
36901
36902 if (!args) SWIG_fail;
36903 swig_obj[0] = args;
36904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36905 if (!SWIG_IsOK(res1)) {
36906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36907 }
36908 arg1 = reinterpret_cast< wxWindow * >(argp1);
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 result = (wxValidator *)(arg1)->GetValidator();
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 {
36916 resultobj = wxPyMake_wxObject(result, (bool)0);
36917 }
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxWindow *arg1 = (wxWindow *) 0 ;
36927 bool result;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 PyObject *swig_obj[1] ;
36931
36932 if (!args) SWIG_fail;
36933 swig_obj[0] = args;
36934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36937 }
36938 arg1 = reinterpret_cast< wxWindow * >(argp1);
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = (bool)(arg1)->Validate();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36947 }
36948 return resultobj;
36949 fail:
36950 return NULL;
36951 }
36952
36953
36954 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36955 PyObject *resultobj = 0;
36956 wxWindow *arg1 = (wxWindow *) 0 ;
36957 bool result;
36958 void *argp1 = 0 ;
36959 int res1 = 0 ;
36960 PyObject *swig_obj[1] ;
36961
36962 if (!args) SWIG_fail;
36963 swig_obj[0] = args;
36964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36965 if (!SWIG_IsOK(res1)) {
36966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36967 }
36968 arg1 = reinterpret_cast< wxWindow * >(argp1);
36969 {
36970 PyThreadState* __tstate = wxPyBeginAllowThreads();
36971 result = (bool)(arg1)->TransferDataToWindow();
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 {
36976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36977 }
36978 return resultobj;
36979 fail:
36980 return NULL;
36981 }
36982
36983
36984 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36985 PyObject *resultobj = 0;
36986 wxWindow *arg1 = (wxWindow *) 0 ;
36987 bool result;
36988 void *argp1 = 0 ;
36989 int res1 = 0 ;
36990 PyObject *swig_obj[1] ;
36991
36992 if (!args) SWIG_fail;
36993 swig_obj[0] = args;
36994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36995 if (!SWIG_IsOK(res1)) {
36996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36997 }
36998 arg1 = reinterpret_cast< wxWindow * >(argp1);
36999 {
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 result = (bool)(arg1)->TransferDataFromWindow();
37002 wxPyEndAllowThreads(__tstate);
37003 if (PyErr_Occurred()) SWIG_fail;
37004 }
37005 {
37006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37007 }
37008 return resultobj;
37009 fail:
37010 return NULL;
37011 }
37012
37013
37014 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37015 PyObject *resultobj = 0;
37016 wxWindow *arg1 = (wxWindow *) 0 ;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 PyObject *swig_obj[1] ;
37020
37021 if (!args) SWIG_fail;
37022 swig_obj[0] = args;
37023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37026 }
37027 arg1 = reinterpret_cast< wxWindow * >(argp1);
37028 {
37029 PyThreadState* __tstate = wxPyBeginAllowThreads();
37030 (arg1)->InitDialog();
37031 wxPyEndAllowThreads(__tstate);
37032 if (PyErr_Occurred()) SWIG_fail;
37033 }
37034 resultobj = SWIG_Py_Void();
37035 return resultobj;
37036 fail:
37037 return NULL;
37038 }
37039
37040
37041 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37042 PyObject *resultobj = 0;
37043 wxWindow *arg1 = (wxWindow *) 0 ;
37044 wxAcceleratorTable *arg2 = 0 ;
37045 void *argp1 = 0 ;
37046 int res1 = 0 ;
37047 void *argp2 = 0 ;
37048 int res2 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 char * kwnames[] = {
37052 (char *) "self",(char *) "accel", NULL
37053 };
37054
37055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37057 if (!SWIG_IsOK(res1)) {
37058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37059 }
37060 arg1 = reinterpret_cast< wxWindow * >(argp1);
37061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37062 if (!SWIG_IsOK(res2)) {
37063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37064 }
37065 if (!argp2) {
37066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37067 }
37068 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 resultobj = SWIG_Py_Void();
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37083 PyObject *resultobj = 0;
37084 wxWindow *arg1 = (wxWindow *) 0 ;
37085 wxAcceleratorTable *result = 0 ;
37086 void *argp1 = 0 ;
37087 int res1 = 0 ;
37088 PyObject *swig_obj[1] ;
37089
37090 if (!args) SWIG_fail;
37091 swig_obj[0] = args;
37092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37093 if (!SWIG_IsOK(res1)) {
37094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37095 }
37096 arg1 = reinterpret_cast< wxWindow * >(argp1);
37097 {
37098 PyThreadState* __tstate = wxPyBeginAllowThreads();
37099 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37100 wxPyEndAllowThreads(__tstate);
37101 if (PyErr_Occurred()) SWIG_fail;
37102 }
37103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37104 return resultobj;
37105 fail:
37106 return NULL;
37107 }
37108
37109
37110 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37111 PyObject *resultobj = 0;
37112 wxWindow *arg1 = (wxWindow *) 0 ;
37113 int arg2 ;
37114 int arg3 ;
37115 int arg4 ;
37116 bool result;
37117 void *argp1 = 0 ;
37118 int res1 = 0 ;
37119 int val2 ;
37120 int ecode2 = 0 ;
37121 int val3 ;
37122 int ecode3 = 0 ;
37123 int val4 ;
37124 int ecode4 = 0 ;
37125 PyObject * obj0 = 0 ;
37126 PyObject * obj1 = 0 ;
37127 PyObject * obj2 = 0 ;
37128 PyObject * obj3 = 0 ;
37129 char * kwnames[] = {
37130 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37131 };
37132
37133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37135 if (!SWIG_IsOK(res1)) {
37136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37137 }
37138 arg1 = reinterpret_cast< wxWindow * >(argp1);
37139 ecode2 = SWIG_AsVal_int(obj1, &val2);
37140 if (!SWIG_IsOK(ecode2)) {
37141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37142 }
37143 arg2 = static_cast< int >(val2);
37144 ecode3 = SWIG_AsVal_int(obj2, &val3);
37145 if (!SWIG_IsOK(ecode3)) {
37146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37147 }
37148 arg3 = static_cast< int >(val3);
37149 ecode4 = SWIG_AsVal_int(obj3, &val4);
37150 if (!SWIG_IsOK(ecode4)) {
37151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37152 }
37153 arg4 = static_cast< int >(val4);
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 {
37161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37162 }
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = 0;
37171 wxWindow *arg1 = (wxWindow *) 0 ;
37172 int arg2 ;
37173 bool result;
37174 void *argp1 = 0 ;
37175 int res1 = 0 ;
37176 int val2 ;
37177 int ecode2 = 0 ;
37178 PyObject * obj0 = 0 ;
37179 PyObject * obj1 = 0 ;
37180 char * kwnames[] = {
37181 (char *) "self",(char *) "hotkeyId", NULL
37182 };
37183
37184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37186 if (!SWIG_IsOK(res1)) {
37187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37188 }
37189 arg1 = reinterpret_cast< wxWindow * >(argp1);
37190 ecode2 = SWIG_AsVal_int(obj1, &val2);
37191 if (!SWIG_IsOK(ecode2)) {
37192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37193 }
37194 arg2 = static_cast< int >(val2);
37195 {
37196 PyThreadState* __tstate = wxPyBeginAllowThreads();
37197 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37198 wxPyEndAllowThreads(__tstate);
37199 if (PyErr_Occurred()) SWIG_fail;
37200 }
37201 {
37202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37203 }
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 wxPoint *arg2 = 0 ;
37214 wxPoint result;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 wxPoint temp2 ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "pt", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 {
37231 arg2 = &temp2;
37232 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37233 }
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37248 PyObject *resultobj = 0;
37249 wxWindow *arg1 = (wxWindow *) 0 ;
37250 wxSize *arg2 = 0 ;
37251 wxSize result;
37252 void *argp1 = 0 ;
37253 int res1 = 0 ;
37254 wxSize temp2 ;
37255 PyObject * obj0 = 0 ;
37256 PyObject * obj1 = 0 ;
37257 char * kwnames[] = {
37258 (char *) "self",(char *) "sz", NULL
37259 };
37260
37261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37263 if (!SWIG_IsOK(res1)) {
37264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37265 }
37266 arg1 = reinterpret_cast< wxWindow * >(argp1);
37267 {
37268 arg2 = &temp2;
37269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37270 }
37271 {
37272 PyThreadState* __tstate = wxPyBeginAllowThreads();
37273 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37274 wxPyEndAllowThreads(__tstate);
37275 if (PyErr_Occurred()) SWIG_fail;
37276 }
37277 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37278 return resultobj;
37279 fail:
37280 return NULL;
37281 }
37282
37283
37284 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37285 PyObject *resultobj = 0;
37286 wxWindow *arg1 = (wxWindow *) 0 ;
37287 wxPoint *arg2 = 0 ;
37288 wxPoint result;
37289 void *argp1 = 0 ;
37290 int res1 = 0 ;
37291 wxPoint temp2 ;
37292 PyObject * obj0 = 0 ;
37293 PyObject * obj1 = 0 ;
37294 char * kwnames[] = {
37295 (char *) "self",(char *) "pt", NULL
37296 };
37297
37298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37300 if (!SWIG_IsOK(res1)) {
37301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37302 }
37303 arg1 = reinterpret_cast< wxWindow * >(argp1);
37304 {
37305 arg2 = &temp2;
37306 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37307 }
37308 {
37309 PyThreadState* __tstate = wxPyBeginAllowThreads();
37310 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37311 wxPyEndAllowThreads(__tstate);
37312 if (PyErr_Occurred()) SWIG_fail;
37313 }
37314 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37322 PyObject *resultobj = 0;
37323 wxWindow *arg1 = (wxWindow *) 0 ;
37324 wxSize *arg2 = 0 ;
37325 wxSize result;
37326 void *argp1 = 0 ;
37327 int res1 = 0 ;
37328 wxSize temp2 ;
37329 PyObject * obj0 = 0 ;
37330 PyObject * obj1 = 0 ;
37331 char * kwnames[] = {
37332 (char *) "self",(char *) "sz", NULL
37333 };
37334
37335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 {
37342 arg2 = &temp2;
37343 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37344 }
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37348 wxPyEndAllowThreads(__tstate);
37349 if (PyErr_Occurred()) SWIG_fail;
37350 }
37351 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37352 return resultobj;
37353 fail:
37354 return NULL;
37355 }
37356
37357
37358 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37359 PyObject *resultobj = 0;
37360 wxWindow *arg1 = (wxWindow *) 0 ;
37361 wxPoint *arg2 = 0 ;
37362 wxPoint result;
37363 void *argp1 = 0 ;
37364 int res1 = 0 ;
37365 wxPoint temp2 ;
37366 PyObject * obj0 = 0 ;
37367 PyObject * obj1 = 0 ;
37368 char * kwnames[] = {
37369 (char *) "self",(char *) "pt", NULL
37370 };
37371
37372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 {
37379 arg2 = &temp2;
37380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37381 }
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj = 0;
37397 wxWindow *arg1 = (wxWindow *) 0 ;
37398 wxSize *arg2 = 0 ;
37399 wxSize result;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 wxSize temp2 ;
37403 PyObject * obj0 = 0 ;
37404 PyObject * obj1 = 0 ;
37405 char * kwnames[] = {
37406 (char *) "self",(char *) "sz", NULL
37407 };
37408
37409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37411 if (!SWIG_IsOK(res1)) {
37412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37413 }
37414 arg1 = reinterpret_cast< wxWindow * >(argp1);
37415 {
37416 arg2 = &temp2;
37417 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37418 }
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 int arg2 ;
37436 int arg3 ;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 int val2 ;
37440 int ecode2 = 0 ;
37441 int val3 ;
37442 int ecode3 = 0 ;
37443 PyObject * obj0 = 0 ;
37444 PyObject * obj1 = 0 ;
37445 PyObject * obj2 = 0 ;
37446 char * kwnames[] = {
37447 (char *) "self",(char *) "x",(char *) "y", NULL
37448 };
37449
37450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37452 if (!SWIG_IsOK(res1)) {
37453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37454 }
37455 arg1 = reinterpret_cast< wxWindow * >(argp1);
37456 ecode2 = SWIG_AsVal_int(obj1, &val2);
37457 if (!SWIG_IsOK(ecode2)) {
37458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37459 }
37460 arg2 = static_cast< int >(val2);
37461 ecode3 = SWIG_AsVal_int(obj2, &val3);
37462 if (!SWIG_IsOK(ecode3)) {
37463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37464 }
37465 arg3 = static_cast< int >(val3);
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 (arg1)->WarpPointer(arg2,arg3);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 resultobj = SWIG_Py_Void();
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37480 PyObject *resultobj = 0;
37481 wxWindow *arg1 = (wxWindow *) 0 ;
37482 void *argp1 = 0 ;
37483 int res1 = 0 ;
37484 PyObject *swig_obj[1] ;
37485
37486 if (!args) SWIG_fail;
37487 swig_obj[0] = args;
37488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 {
37494 PyThreadState* __tstate = wxPyBeginAllowThreads();
37495 (arg1)->CaptureMouse();
37496 wxPyEndAllowThreads(__tstate);
37497 if (PyErr_Occurred()) SWIG_fail;
37498 }
37499 resultobj = SWIG_Py_Void();
37500 return resultobj;
37501 fail:
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37507 PyObject *resultobj = 0;
37508 wxWindow *arg1 = (wxWindow *) 0 ;
37509 void *argp1 = 0 ;
37510 int res1 = 0 ;
37511 PyObject *swig_obj[1] ;
37512
37513 if (!args) SWIG_fail;
37514 swig_obj[0] = args;
37515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37516 if (!SWIG_IsOK(res1)) {
37517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37518 }
37519 arg1 = reinterpret_cast< wxWindow * >(argp1);
37520 {
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 (arg1)->ReleaseMouse();
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 resultobj = SWIG_Py_Void();
37527 return resultobj;
37528 fail:
37529 return NULL;
37530 }
37531
37532
37533 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37534 PyObject *resultobj = 0;
37535 wxWindow *result = 0 ;
37536
37537 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37538 {
37539 if (!wxPyCheckForApp()) SWIG_fail;
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 result = (wxWindow *)wxWindow::GetCapture();
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 {
37546 resultobj = wxPyMake_wxObject(result, 0);
37547 }
37548 return resultobj;
37549 fail:
37550 return NULL;
37551 }
37552
37553
37554 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37555 PyObject *resultobj = 0;
37556 wxWindow *arg1 = (wxWindow *) 0 ;
37557 bool result;
37558 void *argp1 = 0 ;
37559 int res1 = 0 ;
37560 PyObject *swig_obj[1] ;
37561
37562 if (!args) SWIG_fail;
37563 swig_obj[0] = args;
37564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37565 if (!SWIG_IsOK(res1)) {
37566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37567 }
37568 arg1 = reinterpret_cast< wxWindow * >(argp1);
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (bool)((wxWindow const *)arg1)->HasCapture();
37572 wxPyEndAllowThreads(__tstate);
37573 if (PyErr_Occurred()) SWIG_fail;
37574 }
37575 {
37576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37577 }
37578 return resultobj;
37579 fail:
37580 return NULL;
37581 }
37582
37583
37584 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37585 PyObject *resultobj = 0;
37586 wxWindow *arg1 = (wxWindow *) 0 ;
37587 bool arg2 = (bool) true ;
37588 wxRect *arg3 = (wxRect *) NULL ;
37589 void *argp1 = 0 ;
37590 int res1 = 0 ;
37591 bool val2 ;
37592 int ecode2 = 0 ;
37593 void *argp3 = 0 ;
37594 int res3 = 0 ;
37595 PyObject * obj0 = 0 ;
37596 PyObject * obj1 = 0 ;
37597 PyObject * obj2 = 0 ;
37598 char * kwnames[] = {
37599 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37600 };
37601
37602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37604 if (!SWIG_IsOK(res1)) {
37605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37606 }
37607 arg1 = reinterpret_cast< wxWindow * >(argp1);
37608 if (obj1) {
37609 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37610 if (!SWIG_IsOK(ecode2)) {
37611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37612 }
37613 arg2 = static_cast< bool >(val2);
37614 }
37615 if (obj2) {
37616 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37617 if (!SWIG_IsOK(res3)) {
37618 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37619 }
37620 arg3 = reinterpret_cast< wxRect * >(argp3);
37621 }
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 resultobj = SWIG_Py_Void();
37629 return resultobj;
37630 fail:
37631 return NULL;
37632 }
37633
37634
37635 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37636 PyObject *resultobj = 0;
37637 wxWindow *arg1 = (wxWindow *) 0 ;
37638 wxRect *arg2 = 0 ;
37639 bool arg3 = (bool) true ;
37640 void *argp1 = 0 ;
37641 int res1 = 0 ;
37642 wxRect temp2 ;
37643 bool val3 ;
37644 int ecode3 = 0 ;
37645 PyObject * obj0 = 0 ;
37646 PyObject * obj1 = 0 ;
37647 PyObject * obj2 = 0 ;
37648 char * kwnames[] = {
37649 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37650 };
37651
37652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37654 if (!SWIG_IsOK(res1)) {
37655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37656 }
37657 arg1 = reinterpret_cast< wxWindow * >(argp1);
37658 {
37659 arg2 = &temp2;
37660 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37661 }
37662 if (obj2) {
37663 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37664 if (!SWIG_IsOK(ecode3)) {
37665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37666 }
37667 arg3 = static_cast< bool >(val3);
37668 }
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37683 PyObject *resultobj = 0;
37684 wxWindow *arg1 = (wxWindow *) 0 ;
37685 void *argp1 = 0 ;
37686 int res1 = 0 ;
37687 PyObject *swig_obj[1] ;
37688
37689 if (!args) SWIG_fail;
37690 swig_obj[0] = args;
37691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37692 if (!SWIG_IsOK(res1)) {
37693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37694 }
37695 arg1 = reinterpret_cast< wxWindow * >(argp1);
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 (arg1)->Update();
37699 wxPyEndAllowThreads(__tstate);
37700 if (PyErr_Occurred()) SWIG_fail;
37701 }
37702 resultobj = SWIG_Py_Void();
37703 return resultobj;
37704 fail:
37705 return NULL;
37706 }
37707
37708
37709 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37710 PyObject *resultobj = 0;
37711 wxWindow *arg1 = (wxWindow *) 0 ;
37712 void *argp1 = 0 ;
37713 int res1 = 0 ;
37714 PyObject *swig_obj[1] ;
37715
37716 if (!args) SWIG_fail;
37717 swig_obj[0] = args;
37718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37721 }
37722 arg1 = reinterpret_cast< wxWindow * >(argp1);
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 (arg1)->ClearBackground();
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = SWIG_Py_Void();
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37737 PyObject *resultobj = 0;
37738 wxWindow *arg1 = (wxWindow *) 0 ;
37739 void *argp1 = 0 ;
37740 int res1 = 0 ;
37741 PyObject *swig_obj[1] ;
37742
37743 if (!args) SWIG_fail;
37744 swig_obj[0] = args;
37745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37746 if (!SWIG_IsOK(res1)) {
37747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37748 }
37749 arg1 = reinterpret_cast< wxWindow * >(argp1);
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 (arg1)->Freeze();
37753 wxPyEndAllowThreads(__tstate);
37754 if (PyErr_Occurred()) SWIG_fail;
37755 }
37756 resultobj = SWIG_Py_Void();
37757 return resultobj;
37758 fail:
37759 return NULL;
37760 }
37761
37762
37763 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37764 PyObject *resultobj = 0;
37765 wxWindow *arg1 = (wxWindow *) 0 ;
37766 bool result;
37767 void *argp1 = 0 ;
37768 int res1 = 0 ;
37769 PyObject *swig_obj[1] ;
37770
37771 if (!args) SWIG_fail;
37772 swig_obj[0] = args;
37773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37774 if (!SWIG_IsOK(res1)) {
37775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37776 }
37777 arg1 = reinterpret_cast< wxWindow * >(argp1);
37778 {
37779 PyThreadState* __tstate = wxPyBeginAllowThreads();
37780 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 {
37785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37786 }
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37794 PyObject *resultobj = 0;
37795 wxWindow *arg1 = (wxWindow *) 0 ;
37796 void *argp1 = 0 ;
37797 int res1 = 0 ;
37798 PyObject *swig_obj[1] ;
37799
37800 if (!args) SWIG_fail;
37801 swig_obj[0] = args;
37802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37803 if (!SWIG_IsOK(res1)) {
37804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37805 }
37806 arg1 = reinterpret_cast< wxWindow * >(argp1);
37807 {
37808 PyThreadState* __tstate = wxPyBeginAllowThreads();
37809 (arg1)->Thaw();
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 resultobj = SWIG_Py_Void();
37814 return resultobj;
37815 fail:
37816 return NULL;
37817 }
37818
37819
37820 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37821 PyObject *resultobj = 0;
37822 wxWindow *arg1 = (wxWindow *) 0 ;
37823 wxDC *arg2 = 0 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 void *argp2 = 0 ;
37827 int res2 = 0 ;
37828 PyObject * obj0 = 0 ;
37829 PyObject * obj1 = 0 ;
37830 char * kwnames[] = {
37831 (char *) "self",(char *) "dc", NULL
37832 };
37833
37834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37836 if (!SWIG_IsOK(res1)) {
37837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37838 }
37839 arg1 = reinterpret_cast< wxWindow * >(argp1);
37840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37841 if (!SWIG_IsOK(res2)) {
37842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37843 }
37844 if (!argp2) {
37845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37846 }
37847 arg2 = reinterpret_cast< wxDC * >(argp2);
37848 {
37849 PyThreadState* __tstate = wxPyBeginAllowThreads();
37850 (arg1)->PrepareDC(*arg2);
37851 wxPyEndAllowThreads(__tstate);
37852 if (PyErr_Occurred()) SWIG_fail;
37853 }
37854 resultobj = SWIG_Py_Void();
37855 return resultobj;
37856 fail:
37857 return NULL;
37858 }
37859
37860
37861 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37862 PyObject *resultobj = 0;
37863 wxWindow *arg1 = (wxWindow *) 0 ;
37864 bool result;
37865 void *argp1 = 0 ;
37866 int res1 = 0 ;
37867 PyObject *swig_obj[1] ;
37868
37869 if (!args) SWIG_fail;
37870 swig_obj[0] = args;
37871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37872 if (!SWIG_IsOK(res1)) {
37873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37874 }
37875 arg1 = reinterpret_cast< wxWindow * >(argp1);
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 wxWindow *arg1 = (wxWindow *) 0 ;
37894 wxRegion *result = 0 ;
37895 void *argp1 = 0 ;
37896 int res1 = 0 ;
37897 PyObject *swig_obj[1] ;
37898
37899 if (!args) SWIG_fail;
37900 swig_obj[0] = args;
37901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37902 if (!SWIG_IsOK(res1)) {
37903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37904 }
37905 arg1 = reinterpret_cast< wxWindow * >(argp1);
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 {
37909 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37910 result = (wxRegion *) &_result_ref;
37911 }
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37923 PyObject *resultobj = 0;
37924 wxWindow *arg1 = (wxWindow *) 0 ;
37925 wxRect result;
37926 void *argp1 = 0 ;
37927 int res1 = 0 ;
37928 PyObject *swig_obj[1] ;
37929
37930 if (!args) SWIG_fail;
37931 swig_obj[0] = args;
37932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37933 if (!SWIG_IsOK(res1)) {
37934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37935 }
37936 arg1 = reinterpret_cast< wxWindow * >(argp1);
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37940 wxPyEndAllowThreads(__tstate);
37941 if (PyErr_Occurred()) SWIG_fail;
37942 }
37943 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37944 return resultobj;
37945 fail:
37946 return NULL;
37947 }
37948
37949
37950 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37951 PyObject *resultobj = 0;
37952 wxWindow *arg1 = (wxWindow *) 0 ;
37953 int arg2 ;
37954 int arg3 ;
37955 int arg4 = (int) 1 ;
37956 int arg5 = (int) 1 ;
37957 bool result;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 int val2 ;
37961 int ecode2 = 0 ;
37962 int val3 ;
37963 int ecode3 = 0 ;
37964 int val4 ;
37965 int ecode4 = 0 ;
37966 int val5 ;
37967 int ecode5 = 0 ;
37968 PyObject * obj0 = 0 ;
37969 PyObject * obj1 = 0 ;
37970 PyObject * obj2 = 0 ;
37971 PyObject * obj3 = 0 ;
37972 PyObject * obj4 = 0 ;
37973 char * kwnames[] = {
37974 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37975 };
37976
37977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37979 if (!SWIG_IsOK(res1)) {
37980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37981 }
37982 arg1 = reinterpret_cast< wxWindow * >(argp1);
37983 ecode2 = SWIG_AsVal_int(obj1, &val2);
37984 if (!SWIG_IsOK(ecode2)) {
37985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37986 }
37987 arg2 = static_cast< int >(val2);
37988 ecode3 = SWIG_AsVal_int(obj2, &val3);
37989 if (!SWIG_IsOK(ecode3)) {
37990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37991 }
37992 arg3 = static_cast< int >(val3);
37993 if (obj3) {
37994 ecode4 = SWIG_AsVal_int(obj3, &val4);
37995 if (!SWIG_IsOK(ecode4)) {
37996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37997 }
37998 arg4 = static_cast< int >(val4);
37999 }
38000 if (obj4) {
38001 ecode5 = SWIG_AsVal_int(obj4, &val5);
38002 if (!SWIG_IsOK(ecode5)) {
38003 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38004 }
38005 arg5 = static_cast< int >(val5);
38006 }
38007 {
38008 PyThreadState* __tstate = wxPyBeginAllowThreads();
38009 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 {
38014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38015 }
38016 return resultobj;
38017 fail:
38018 return NULL;
38019 }
38020
38021
38022 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38023 PyObject *resultobj = 0;
38024 wxWindow *arg1 = (wxWindow *) 0 ;
38025 wxPoint *arg2 = 0 ;
38026 bool result;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 wxPoint temp2 ;
38030 PyObject * obj0 = 0 ;
38031 PyObject * obj1 = 0 ;
38032 char * kwnames[] = {
38033 (char *) "self",(char *) "pt", NULL
38034 };
38035
38036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38038 if (!SWIG_IsOK(res1)) {
38039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38040 }
38041 arg1 = reinterpret_cast< wxWindow * >(argp1);
38042 {
38043 arg2 = &temp2;
38044 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38045 }
38046 {
38047 PyThreadState* __tstate = wxPyBeginAllowThreads();
38048 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38049 wxPyEndAllowThreads(__tstate);
38050 if (PyErr_Occurred()) SWIG_fail;
38051 }
38052 {
38053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38054 }
38055 return resultobj;
38056 fail:
38057 return NULL;
38058 }
38059
38060
38061 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38062 PyObject *resultobj = 0;
38063 wxWindow *arg1 = (wxWindow *) 0 ;
38064 wxRect *arg2 = 0 ;
38065 bool result;
38066 void *argp1 = 0 ;
38067 int res1 = 0 ;
38068 wxRect temp2 ;
38069 PyObject * obj0 = 0 ;
38070 PyObject * obj1 = 0 ;
38071 char * kwnames[] = {
38072 (char *) "self",(char *) "rect", NULL
38073 };
38074
38075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38077 if (!SWIG_IsOK(res1)) {
38078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38079 }
38080 arg1 = reinterpret_cast< wxWindow * >(argp1);
38081 {
38082 arg2 = &temp2;
38083 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38084 }
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 {
38092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38093 }
38094 return resultobj;
38095 fail:
38096 return NULL;
38097 }
38098
38099
38100 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38101 PyObject *resultobj = 0;
38102 wxWindow *arg1 = (wxWindow *) 0 ;
38103 SwigValueWrapper<wxVisualAttributes > result;
38104 void *argp1 = 0 ;
38105 int res1 = 0 ;
38106 PyObject *swig_obj[1] ;
38107
38108 if (!args) SWIG_fail;
38109 swig_obj[0] = args;
38110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38111 if (!SWIG_IsOK(res1)) {
38112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38113 }
38114 arg1 = reinterpret_cast< wxWindow * >(argp1);
38115 {
38116 PyThreadState* __tstate = wxPyBeginAllowThreads();
38117 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38122 return resultobj;
38123 fail:
38124 return NULL;
38125 }
38126
38127
38128 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38129 PyObject *resultobj = 0;
38130 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38131 SwigValueWrapper<wxVisualAttributes > result;
38132 int val1 ;
38133 int ecode1 = 0 ;
38134 PyObject * obj0 = 0 ;
38135 char * kwnames[] = {
38136 (char *) "variant", NULL
38137 };
38138
38139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38140 if (obj0) {
38141 ecode1 = SWIG_AsVal_int(obj0, &val1);
38142 if (!SWIG_IsOK(ecode1)) {
38143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38144 }
38145 arg1 = static_cast< wxWindowVariant >(val1);
38146 }
38147 {
38148 if (!wxPyCheckForApp()) SWIG_fail;
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 result = wxWindow::GetClassDefaultAttributes(arg1);
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38162 PyObject *resultobj = 0;
38163 wxWindow *arg1 = (wxWindow *) 0 ;
38164 wxColour *arg2 = 0 ;
38165 bool result;
38166 void *argp1 = 0 ;
38167 int res1 = 0 ;
38168 wxColour temp2 ;
38169 PyObject * obj0 = 0 ;
38170 PyObject * obj1 = 0 ;
38171 char * kwnames[] = {
38172 (char *) "self",(char *) "colour", NULL
38173 };
38174
38175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38177 if (!SWIG_IsOK(res1)) {
38178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38179 }
38180 arg1 = reinterpret_cast< wxWindow * >(argp1);
38181 {
38182 arg2 = &temp2;
38183 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38184 }
38185 {
38186 PyThreadState* __tstate = wxPyBeginAllowThreads();
38187 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38188 wxPyEndAllowThreads(__tstate);
38189 if (PyErr_Occurred()) SWIG_fail;
38190 }
38191 {
38192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38193 }
38194 return resultobj;
38195 fail:
38196 return NULL;
38197 }
38198
38199
38200 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38201 PyObject *resultobj = 0;
38202 wxWindow *arg1 = (wxWindow *) 0 ;
38203 wxColour *arg2 = 0 ;
38204 void *argp1 = 0 ;
38205 int res1 = 0 ;
38206 wxColour temp2 ;
38207 PyObject * obj0 = 0 ;
38208 PyObject * obj1 = 0 ;
38209 char * kwnames[] = {
38210 (char *) "self",(char *) "colour", NULL
38211 };
38212
38213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38215 if (!SWIG_IsOK(res1)) {
38216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38217 }
38218 arg1 = reinterpret_cast< wxWindow * >(argp1);
38219 {
38220 arg2 = &temp2;
38221 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38222 }
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38226 wxPyEndAllowThreads(__tstate);
38227 if (PyErr_Occurred()) SWIG_fail;
38228 }
38229 resultobj = SWIG_Py_Void();
38230 return resultobj;
38231 fail:
38232 return NULL;
38233 }
38234
38235
38236 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38237 PyObject *resultobj = 0;
38238 wxWindow *arg1 = (wxWindow *) 0 ;
38239 wxColour *arg2 = 0 ;
38240 bool result;
38241 void *argp1 = 0 ;
38242 int res1 = 0 ;
38243 wxColour temp2 ;
38244 PyObject * obj0 = 0 ;
38245 PyObject * obj1 = 0 ;
38246 char * kwnames[] = {
38247 (char *) "self",(char *) "colour", NULL
38248 };
38249
38250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38254 }
38255 arg1 = reinterpret_cast< wxWindow * >(argp1);
38256 {
38257 arg2 = &temp2;
38258 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38259 }
38260 {
38261 PyThreadState* __tstate = wxPyBeginAllowThreads();
38262 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 {
38267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38268 }
38269 return resultobj;
38270 fail:
38271 return NULL;
38272 }
38273
38274
38275 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38276 PyObject *resultobj = 0;
38277 wxWindow *arg1 = (wxWindow *) 0 ;
38278 wxColour *arg2 = 0 ;
38279 void *argp1 = 0 ;
38280 int res1 = 0 ;
38281 wxColour temp2 ;
38282 PyObject * obj0 = 0 ;
38283 PyObject * obj1 = 0 ;
38284 char * kwnames[] = {
38285 (char *) "self",(char *) "colour", NULL
38286 };
38287
38288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38292 }
38293 arg1 = reinterpret_cast< wxWindow * >(argp1);
38294 {
38295 arg2 = &temp2;
38296 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38297 }
38298 {
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38301 wxPyEndAllowThreads(__tstate);
38302 if (PyErr_Occurred()) SWIG_fail;
38303 }
38304 resultobj = SWIG_Py_Void();
38305 return resultobj;
38306 fail:
38307 return NULL;
38308 }
38309
38310
38311 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38312 PyObject *resultobj = 0;
38313 wxWindow *arg1 = (wxWindow *) 0 ;
38314 wxColour result;
38315 void *argp1 = 0 ;
38316 int res1 = 0 ;
38317 PyObject *swig_obj[1] ;
38318
38319 if (!args) SWIG_fail;
38320 swig_obj[0] = args;
38321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38324 }
38325 arg1 = reinterpret_cast< wxWindow * >(argp1);
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38333 return resultobj;
38334 fail:
38335 return NULL;
38336 }
38337
38338
38339 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38340 PyObject *resultobj = 0;
38341 wxWindow *arg1 = (wxWindow *) 0 ;
38342 wxColour result;
38343 void *argp1 = 0 ;
38344 int res1 = 0 ;
38345 PyObject *swig_obj[1] ;
38346
38347 if (!args) SWIG_fail;
38348 swig_obj[0] = args;
38349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38350 if (!SWIG_IsOK(res1)) {
38351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38352 }
38353 arg1 = reinterpret_cast< wxWindow * >(argp1);
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 result = ((wxWindow const *)arg1)->GetForegroundColour();
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38361 return resultobj;
38362 fail:
38363 return NULL;
38364 }
38365
38366
38367 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38368 PyObject *resultobj = 0;
38369 wxWindow *arg1 = (wxWindow *) 0 ;
38370 bool result;
38371 void *argp1 = 0 ;
38372 int res1 = 0 ;
38373 PyObject *swig_obj[1] ;
38374
38375 if (!args) SWIG_fail;
38376 swig_obj[0] = args;
38377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38378 if (!SWIG_IsOK(res1)) {
38379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38380 }
38381 arg1 = reinterpret_cast< wxWindow * >(argp1);
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 {
38389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38390 }
38391 return resultobj;
38392 fail:
38393 return NULL;
38394 }
38395
38396
38397 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38398 PyObject *resultobj = 0;
38399 wxWindow *arg1 = (wxWindow *) 0 ;
38400 bool result;
38401 void *argp1 = 0 ;
38402 int res1 = 0 ;
38403 PyObject *swig_obj[1] ;
38404
38405 if (!args) SWIG_fail;
38406 swig_obj[0] = args;
38407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38408 if (!SWIG_IsOK(res1)) {
38409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38410 }
38411 arg1 = reinterpret_cast< wxWindow * >(argp1);
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 {
38419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38420 }
38421 return resultobj;
38422 fail:
38423 return NULL;
38424 }
38425
38426
38427 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38428 PyObject *resultobj = 0;
38429 wxWindow *arg1 = (wxWindow *) 0 ;
38430 wxBackgroundStyle arg2 ;
38431 bool result;
38432 void *argp1 = 0 ;
38433 int res1 = 0 ;
38434 int val2 ;
38435 int ecode2 = 0 ;
38436 PyObject * obj0 = 0 ;
38437 PyObject * obj1 = 0 ;
38438 char * kwnames[] = {
38439 (char *) "self",(char *) "style", NULL
38440 };
38441
38442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38444 if (!SWIG_IsOK(res1)) {
38445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38446 }
38447 arg1 = reinterpret_cast< wxWindow * >(argp1);
38448 ecode2 = SWIG_AsVal_int(obj1, &val2);
38449 if (!SWIG_IsOK(ecode2)) {
38450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38451 }
38452 arg2 = static_cast< wxBackgroundStyle >(val2);
38453 {
38454 PyThreadState* __tstate = wxPyBeginAllowThreads();
38455 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38456 wxPyEndAllowThreads(__tstate);
38457 if (PyErr_Occurred()) SWIG_fail;
38458 }
38459 {
38460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38461 }
38462 return resultobj;
38463 fail:
38464 return NULL;
38465 }
38466
38467
38468 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38469 PyObject *resultobj = 0;
38470 wxWindow *arg1 = (wxWindow *) 0 ;
38471 wxBackgroundStyle result;
38472 void *argp1 = 0 ;
38473 int res1 = 0 ;
38474 PyObject *swig_obj[1] ;
38475
38476 if (!args) SWIG_fail;
38477 swig_obj[0] = args;
38478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38479 if (!SWIG_IsOK(res1)) {
38480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38481 }
38482 arg1 = reinterpret_cast< wxWindow * >(argp1);
38483 {
38484 PyThreadState* __tstate = wxPyBeginAllowThreads();
38485 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38486 wxPyEndAllowThreads(__tstate);
38487 if (PyErr_Occurred()) SWIG_fail;
38488 }
38489 resultobj = SWIG_From_int(static_cast< int >(result));
38490 return resultobj;
38491 fail:
38492 return NULL;
38493 }
38494
38495
38496 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38497 PyObject *resultobj = 0;
38498 wxWindow *arg1 = (wxWindow *) 0 ;
38499 bool result;
38500 void *argp1 = 0 ;
38501 int res1 = 0 ;
38502 PyObject *swig_obj[1] ;
38503
38504 if (!args) SWIG_fail;
38505 swig_obj[0] = args;
38506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38507 if (!SWIG_IsOK(res1)) {
38508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38509 }
38510 arg1 = reinterpret_cast< wxWindow * >(argp1);
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 result = (bool)(arg1)->HasTransparentBackground();
38514 wxPyEndAllowThreads(__tstate);
38515 if (PyErr_Occurred()) SWIG_fail;
38516 }
38517 {
38518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38519 }
38520 return resultobj;
38521 fail:
38522 return NULL;
38523 }
38524
38525
38526 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38527 PyObject *resultobj = 0;
38528 wxWindow *arg1 = (wxWindow *) 0 ;
38529 wxCursor *arg2 = 0 ;
38530 bool result;
38531 void *argp1 = 0 ;
38532 int res1 = 0 ;
38533 void *argp2 = 0 ;
38534 int res2 = 0 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 char * kwnames[] = {
38538 (char *) "self",(char *) "cursor", NULL
38539 };
38540
38541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38543 if (!SWIG_IsOK(res1)) {
38544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38545 }
38546 arg1 = reinterpret_cast< wxWindow * >(argp1);
38547 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38548 if (!SWIG_IsOK(res2)) {
38549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38550 }
38551 if (!argp2) {
38552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38553 }
38554 arg2 = reinterpret_cast< wxCursor * >(argp2);
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38558 wxPyEndAllowThreads(__tstate);
38559 if (PyErr_Occurred()) SWIG_fail;
38560 }
38561 {
38562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38563 }
38564 return resultobj;
38565 fail:
38566 return NULL;
38567 }
38568
38569
38570 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38571 PyObject *resultobj = 0;
38572 wxWindow *arg1 = (wxWindow *) 0 ;
38573 wxCursor result;
38574 void *argp1 = 0 ;
38575 int res1 = 0 ;
38576 PyObject *swig_obj[1] ;
38577
38578 if (!args) SWIG_fail;
38579 swig_obj[0] = args;
38580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38581 if (!SWIG_IsOK(res1)) {
38582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38583 }
38584 arg1 = reinterpret_cast< wxWindow * >(argp1);
38585 {
38586 PyThreadState* __tstate = wxPyBeginAllowThreads();
38587 result = (arg1)->GetCursor();
38588 wxPyEndAllowThreads(__tstate);
38589 if (PyErr_Occurred()) SWIG_fail;
38590 }
38591 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38592 return resultobj;
38593 fail:
38594 return NULL;
38595 }
38596
38597
38598 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj = 0;
38600 wxWindow *arg1 = (wxWindow *) 0 ;
38601 wxFont *arg2 = 0 ;
38602 bool result;
38603 void *argp1 = 0 ;
38604 int res1 = 0 ;
38605 void *argp2 = 0 ;
38606 int res2 = 0 ;
38607 PyObject * obj0 = 0 ;
38608 PyObject * obj1 = 0 ;
38609 char * kwnames[] = {
38610 (char *) "self",(char *) "font", NULL
38611 };
38612
38613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38615 if (!SWIG_IsOK(res1)) {
38616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38617 }
38618 arg1 = reinterpret_cast< wxWindow * >(argp1);
38619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38620 if (!SWIG_IsOK(res2)) {
38621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38622 }
38623 if (!argp2) {
38624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38625 }
38626 arg2 = reinterpret_cast< wxFont * >(argp2);
38627 {
38628 PyThreadState* __tstate = wxPyBeginAllowThreads();
38629 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38630 wxPyEndAllowThreads(__tstate);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 }
38633 {
38634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38635 }
38636 return resultobj;
38637 fail:
38638 return NULL;
38639 }
38640
38641
38642 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38643 PyObject *resultobj = 0;
38644 wxWindow *arg1 = (wxWindow *) 0 ;
38645 wxFont *arg2 = 0 ;
38646 void *argp1 = 0 ;
38647 int res1 = 0 ;
38648 void *argp2 = 0 ;
38649 int res2 = 0 ;
38650 PyObject * obj0 = 0 ;
38651 PyObject * obj1 = 0 ;
38652 char * kwnames[] = {
38653 (char *) "self",(char *) "font", NULL
38654 };
38655
38656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38658 if (!SWIG_IsOK(res1)) {
38659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38660 }
38661 arg1 = reinterpret_cast< wxWindow * >(argp1);
38662 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38663 if (!SWIG_IsOK(res2)) {
38664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38665 }
38666 if (!argp2) {
38667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38668 }
38669 arg2 = reinterpret_cast< wxFont * >(argp2);
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 (arg1)->SetOwnFont((wxFont const &)*arg2);
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 resultobj = SWIG_Py_Void();
38677 return resultobj;
38678 fail:
38679 return NULL;
38680 }
38681
38682
38683 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38684 PyObject *resultobj = 0;
38685 wxWindow *arg1 = (wxWindow *) 0 ;
38686 wxFont result;
38687 void *argp1 = 0 ;
38688 int res1 = 0 ;
38689 PyObject *swig_obj[1] ;
38690
38691 if (!args) SWIG_fail;
38692 swig_obj[0] = args;
38693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38694 if (!SWIG_IsOK(res1)) {
38695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38696 }
38697 arg1 = reinterpret_cast< wxWindow * >(argp1);
38698 {
38699 PyThreadState* __tstate = wxPyBeginAllowThreads();
38700 result = (arg1)->GetFont();
38701 wxPyEndAllowThreads(__tstate);
38702 if (PyErr_Occurred()) SWIG_fail;
38703 }
38704 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38705 return resultobj;
38706 fail:
38707 return NULL;
38708 }
38709
38710
38711 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38712 PyObject *resultobj = 0;
38713 wxWindow *arg1 = (wxWindow *) 0 ;
38714 wxCaret *arg2 = (wxCaret *) 0 ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 int res2 = 0 ;
38718 PyObject * obj0 = 0 ;
38719 PyObject * obj1 = 0 ;
38720 char * kwnames[] = {
38721 (char *) "self",(char *) "caret", NULL
38722 };
38723
38724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38728 }
38729 arg1 = reinterpret_cast< wxWindow * >(argp1);
38730 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38731 if (!SWIG_IsOK(res2)) {
38732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38733 }
38734 {
38735 PyThreadState* __tstate = wxPyBeginAllowThreads();
38736 (arg1)->SetCaret(arg2);
38737 wxPyEndAllowThreads(__tstate);
38738 if (PyErr_Occurred()) SWIG_fail;
38739 }
38740 resultobj = SWIG_Py_Void();
38741 return resultobj;
38742 fail:
38743 return NULL;
38744 }
38745
38746
38747 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38748 PyObject *resultobj = 0;
38749 wxWindow *arg1 = (wxWindow *) 0 ;
38750 wxCaret *result = 0 ;
38751 void *argp1 = 0 ;
38752 int res1 = 0 ;
38753 PyObject *swig_obj[1] ;
38754
38755 if (!args) SWIG_fail;
38756 swig_obj[0] = args;
38757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38760 }
38761 arg1 = reinterpret_cast< wxWindow * >(argp1);
38762 {
38763 PyThreadState* __tstate = wxPyBeginAllowThreads();
38764 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38765 wxPyEndAllowThreads(__tstate);
38766 if (PyErr_Occurred()) SWIG_fail;
38767 }
38768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38769 return resultobj;
38770 fail:
38771 return NULL;
38772 }
38773
38774
38775 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38776 PyObject *resultobj = 0;
38777 wxWindow *arg1 = (wxWindow *) 0 ;
38778 int result;
38779 void *argp1 = 0 ;
38780 int res1 = 0 ;
38781 PyObject *swig_obj[1] ;
38782
38783 if (!args) SWIG_fail;
38784 swig_obj[0] = args;
38785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38786 if (!SWIG_IsOK(res1)) {
38787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38788 }
38789 arg1 = reinterpret_cast< wxWindow * >(argp1);
38790 {
38791 PyThreadState* __tstate = wxPyBeginAllowThreads();
38792 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 resultobj = SWIG_From_int(static_cast< int >(result));
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38804 PyObject *resultobj = 0;
38805 wxWindow *arg1 = (wxWindow *) 0 ;
38806 int result;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 PyObject *swig_obj[1] ;
38810
38811 if (!args) SWIG_fail;
38812 swig_obj[0] = args;
38813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38814 if (!SWIG_IsOK(res1)) {
38815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38816 }
38817 arg1 = reinterpret_cast< wxWindow * >(argp1);
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38821 wxPyEndAllowThreads(__tstate);
38822 if (PyErr_Occurred()) SWIG_fail;
38823 }
38824 resultobj = SWIG_From_int(static_cast< int >(result));
38825 return resultobj;
38826 fail:
38827 return NULL;
38828 }
38829
38830
38831 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38832 PyObject *resultobj = 0;
38833 wxWindow *arg1 = (wxWindow *) 0 ;
38834 wxString *arg2 = 0 ;
38835 int *arg3 = (int *) 0 ;
38836 int *arg4 = (int *) 0 ;
38837 void *argp1 = 0 ;
38838 int res1 = 0 ;
38839 bool temp2 = false ;
38840 int temp3 ;
38841 int res3 = SWIG_TMPOBJ ;
38842 int temp4 ;
38843 int res4 = SWIG_TMPOBJ ;
38844 PyObject * obj0 = 0 ;
38845 PyObject * obj1 = 0 ;
38846 char * kwnames[] = {
38847 (char *) "self",(char *) "string", NULL
38848 };
38849
38850 arg3 = &temp3;
38851 arg4 = &temp4;
38852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38854 if (!SWIG_IsOK(res1)) {
38855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38856 }
38857 arg1 = reinterpret_cast< wxWindow * >(argp1);
38858 {
38859 arg2 = wxString_in_helper(obj1);
38860 if (arg2 == NULL) SWIG_fail;
38861 temp2 = true;
38862 }
38863 {
38864 PyThreadState* __tstate = wxPyBeginAllowThreads();
38865 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38866 wxPyEndAllowThreads(__tstate);
38867 if (PyErr_Occurred()) SWIG_fail;
38868 }
38869 resultobj = SWIG_Py_Void();
38870 if (SWIG_IsTmpObj(res3)) {
38871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38872 } else {
38873 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38875 }
38876 if (SWIG_IsTmpObj(res4)) {
38877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38878 } else {
38879 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38881 }
38882 {
38883 if (temp2)
38884 delete arg2;
38885 }
38886 return resultobj;
38887 fail:
38888 {
38889 if (temp2)
38890 delete arg2;
38891 }
38892 return NULL;
38893 }
38894
38895
38896 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38897 PyObject *resultobj = 0;
38898 wxWindow *arg1 = (wxWindow *) 0 ;
38899 wxString *arg2 = 0 ;
38900 int *arg3 = (int *) 0 ;
38901 int *arg4 = (int *) 0 ;
38902 int *arg5 = (int *) 0 ;
38903 int *arg6 = (int *) 0 ;
38904 wxFont *arg7 = (wxFont *) NULL ;
38905 void *argp1 = 0 ;
38906 int res1 = 0 ;
38907 bool temp2 = false ;
38908 int temp3 ;
38909 int res3 = SWIG_TMPOBJ ;
38910 int temp4 ;
38911 int res4 = SWIG_TMPOBJ ;
38912 int temp5 ;
38913 int res5 = SWIG_TMPOBJ ;
38914 int temp6 ;
38915 int res6 = SWIG_TMPOBJ ;
38916 void *argp7 = 0 ;
38917 int res7 = 0 ;
38918 PyObject * obj0 = 0 ;
38919 PyObject * obj1 = 0 ;
38920 PyObject * obj2 = 0 ;
38921 char * kwnames[] = {
38922 (char *) "self",(char *) "string",(char *) "font", NULL
38923 };
38924
38925 arg3 = &temp3;
38926 arg4 = &temp4;
38927 arg5 = &temp5;
38928 arg6 = &temp6;
38929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38931 if (!SWIG_IsOK(res1)) {
38932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38933 }
38934 arg1 = reinterpret_cast< wxWindow * >(argp1);
38935 {
38936 arg2 = wxString_in_helper(obj1);
38937 if (arg2 == NULL) SWIG_fail;
38938 temp2 = true;
38939 }
38940 if (obj2) {
38941 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38942 if (!SWIG_IsOK(res7)) {
38943 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38944 }
38945 arg7 = reinterpret_cast< wxFont * >(argp7);
38946 }
38947 {
38948 PyThreadState* __tstate = wxPyBeginAllowThreads();
38949 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38950 wxPyEndAllowThreads(__tstate);
38951 if (PyErr_Occurred()) SWIG_fail;
38952 }
38953 resultobj = SWIG_Py_Void();
38954 if (SWIG_IsTmpObj(res3)) {
38955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38956 } else {
38957 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38959 }
38960 if (SWIG_IsTmpObj(res4)) {
38961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38962 } else {
38963 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38965 }
38966 if (SWIG_IsTmpObj(res5)) {
38967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38968 } else {
38969 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38971 }
38972 if (SWIG_IsTmpObj(res6)) {
38973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38974 } else {
38975 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38977 }
38978 {
38979 if (temp2)
38980 delete arg2;
38981 }
38982 return resultobj;
38983 fail:
38984 {
38985 if (temp2)
38986 delete arg2;
38987 }
38988 return NULL;
38989 }
38990
38991
38992 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj = 0;
38994 wxWindow *arg1 = (wxWindow *) 0 ;
38995 int *arg2 = (int *) 0 ;
38996 int *arg3 = (int *) 0 ;
38997 void *argp1 = 0 ;
38998 int res1 = 0 ;
38999 int temp2 ;
39000 int res2 = 0 ;
39001 int temp3 ;
39002 int res3 = 0 ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 PyObject * obj2 = 0 ;
39006 char * kwnames[] = {
39007 (char *) "self",(char *) "x",(char *) "y", NULL
39008 };
39009
39010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39012 if (!SWIG_IsOK(res1)) {
39013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39014 }
39015 arg1 = reinterpret_cast< wxWindow * >(argp1);
39016 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39017 int val;
39018 int ecode = SWIG_AsVal_int(obj1, &val);
39019 if (!SWIG_IsOK(ecode)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39021 }
39022 temp2 = static_cast< int >(val);
39023 arg2 = &temp2;
39024 res2 = SWIG_AddTmpMask(ecode);
39025 }
39026 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39027 int val;
39028 int ecode = SWIG_AsVal_int(obj2, &val);
39029 if (!SWIG_IsOK(ecode)) {
39030 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39031 }
39032 temp3 = static_cast< int >(val);
39033 arg3 = &temp3;
39034 res3 = SWIG_AddTmpMask(ecode);
39035 }
39036 {
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39039 wxPyEndAllowThreads(__tstate);
39040 if (PyErr_Occurred()) SWIG_fail;
39041 }
39042 resultobj = SWIG_Py_Void();
39043 if (SWIG_IsTmpObj(res2)) {
39044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39045 } else {
39046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39048 }
39049 if (SWIG_IsTmpObj(res3)) {
39050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39051 } else {
39052 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39054 }
39055 return resultobj;
39056 fail:
39057 return NULL;
39058 }
39059
39060
39061 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39062 PyObject *resultobj = 0;
39063 wxWindow *arg1 = (wxWindow *) 0 ;
39064 int *arg2 = (int *) 0 ;
39065 int *arg3 = (int *) 0 ;
39066 void *argp1 = 0 ;
39067 int res1 = 0 ;
39068 int temp2 ;
39069 int res2 = 0 ;
39070 int temp3 ;
39071 int res3 = 0 ;
39072 PyObject * obj0 = 0 ;
39073 PyObject * obj1 = 0 ;
39074 PyObject * obj2 = 0 ;
39075 char * kwnames[] = {
39076 (char *) "self",(char *) "x",(char *) "y", NULL
39077 };
39078
39079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39081 if (!SWIG_IsOK(res1)) {
39082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39083 }
39084 arg1 = reinterpret_cast< wxWindow * >(argp1);
39085 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39086 int val;
39087 int ecode = SWIG_AsVal_int(obj1, &val);
39088 if (!SWIG_IsOK(ecode)) {
39089 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39090 }
39091 temp2 = static_cast< int >(val);
39092 arg2 = &temp2;
39093 res2 = SWIG_AddTmpMask(ecode);
39094 }
39095 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39096 int val;
39097 int ecode = SWIG_AsVal_int(obj2, &val);
39098 if (!SWIG_IsOK(ecode)) {
39099 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39100 }
39101 temp3 = static_cast< int >(val);
39102 arg3 = &temp3;
39103 res3 = SWIG_AddTmpMask(ecode);
39104 }
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39108 wxPyEndAllowThreads(__tstate);
39109 if (PyErr_Occurred()) SWIG_fail;
39110 }
39111 resultobj = SWIG_Py_Void();
39112 if (SWIG_IsTmpObj(res2)) {
39113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39114 } else {
39115 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39117 }
39118 if (SWIG_IsTmpObj(res3)) {
39119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39120 } else {
39121 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39123 }
39124 return resultobj;
39125 fail:
39126 return NULL;
39127 }
39128
39129
39130 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39131 PyObject *resultobj = 0;
39132 wxWindow *arg1 = (wxWindow *) 0 ;
39133 wxPoint *arg2 = 0 ;
39134 wxPoint result;
39135 void *argp1 = 0 ;
39136 int res1 = 0 ;
39137 wxPoint temp2 ;
39138 PyObject * obj0 = 0 ;
39139 PyObject * obj1 = 0 ;
39140 char * kwnames[] = {
39141 (char *) "self",(char *) "pt", NULL
39142 };
39143
39144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39146 if (!SWIG_IsOK(res1)) {
39147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39148 }
39149 arg1 = reinterpret_cast< wxWindow * >(argp1);
39150 {
39151 arg2 = &temp2;
39152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39153 }
39154 {
39155 PyThreadState* __tstate = wxPyBeginAllowThreads();
39156 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39157 wxPyEndAllowThreads(__tstate);
39158 if (PyErr_Occurred()) SWIG_fail;
39159 }
39160 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39161 return resultobj;
39162 fail:
39163 return NULL;
39164 }
39165
39166
39167 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39168 PyObject *resultobj = 0;
39169 wxWindow *arg1 = (wxWindow *) 0 ;
39170 wxPoint *arg2 = 0 ;
39171 wxPoint result;
39172 void *argp1 = 0 ;
39173 int res1 = 0 ;
39174 wxPoint temp2 ;
39175 PyObject * obj0 = 0 ;
39176 PyObject * obj1 = 0 ;
39177 char * kwnames[] = {
39178 (char *) "self",(char *) "pt", NULL
39179 };
39180
39181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39183 if (!SWIG_IsOK(res1)) {
39184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39185 }
39186 arg1 = reinterpret_cast< wxWindow * >(argp1);
39187 {
39188 arg2 = &temp2;
39189 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39190 }
39191 {
39192 PyThreadState* __tstate = wxPyBeginAllowThreads();
39193 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39194 wxPyEndAllowThreads(__tstate);
39195 if (PyErr_Occurred()) SWIG_fail;
39196 }
39197 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39198 return resultobj;
39199 fail:
39200 return NULL;
39201 }
39202
39203
39204 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj = 0;
39206 wxWindow *arg1 = (wxWindow *) 0 ;
39207 int arg2 ;
39208 int arg3 ;
39209 wxHitTest result;
39210 void *argp1 = 0 ;
39211 int res1 = 0 ;
39212 int val2 ;
39213 int ecode2 = 0 ;
39214 int val3 ;
39215 int ecode3 = 0 ;
39216 PyObject * obj0 = 0 ;
39217 PyObject * obj1 = 0 ;
39218 PyObject * obj2 = 0 ;
39219 char * kwnames[] = {
39220 (char *) "self",(char *) "x",(char *) "y", NULL
39221 };
39222
39223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39225 if (!SWIG_IsOK(res1)) {
39226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39227 }
39228 arg1 = reinterpret_cast< wxWindow * >(argp1);
39229 ecode2 = SWIG_AsVal_int(obj1, &val2);
39230 if (!SWIG_IsOK(ecode2)) {
39231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39232 }
39233 arg2 = static_cast< int >(val2);
39234 ecode3 = SWIG_AsVal_int(obj2, &val3);
39235 if (!SWIG_IsOK(ecode3)) {
39236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39237 }
39238 arg3 = static_cast< int >(val3);
39239 {
39240 PyThreadState* __tstate = wxPyBeginAllowThreads();
39241 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39242 wxPyEndAllowThreads(__tstate);
39243 if (PyErr_Occurred()) SWIG_fail;
39244 }
39245 resultobj = SWIG_From_int(static_cast< int >(result));
39246 return resultobj;
39247 fail:
39248 return NULL;
39249 }
39250
39251
39252 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39253 PyObject *resultobj = 0;
39254 wxWindow *arg1 = (wxWindow *) 0 ;
39255 wxPoint *arg2 = 0 ;
39256 wxHitTest result;
39257 void *argp1 = 0 ;
39258 int res1 = 0 ;
39259 wxPoint temp2 ;
39260 PyObject * obj0 = 0 ;
39261 PyObject * obj1 = 0 ;
39262 char * kwnames[] = {
39263 (char *) "self",(char *) "pt", NULL
39264 };
39265
39266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39268 if (!SWIG_IsOK(res1)) {
39269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39270 }
39271 arg1 = reinterpret_cast< wxWindow * >(argp1);
39272 {
39273 arg2 = &temp2;
39274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39275 }
39276 {
39277 PyThreadState* __tstate = wxPyBeginAllowThreads();
39278 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39279 wxPyEndAllowThreads(__tstate);
39280 if (PyErr_Occurred()) SWIG_fail;
39281 }
39282 resultobj = SWIG_From_int(static_cast< int >(result));
39283 return resultobj;
39284 fail:
39285 return NULL;
39286 }
39287
39288
39289 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39290 PyObject *resultobj = 0;
39291 wxWindow *arg1 = (wxWindow *) 0 ;
39292 long arg2 ;
39293 wxBorder result;
39294 void *argp1 = 0 ;
39295 int res1 = 0 ;
39296 long val2 ;
39297 int ecode2 = 0 ;
39298
39299 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39301 if (!SWIG_IsOK(res1)) {
39302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39303 }
39304 arg1 = reinterpret_cast< wxWindow * >(argp1);
39305 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39306 if (!SWIG_IsOK(ecode2)) {
39307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39308 }
39309 arg2 = static_cast< long >(val2);
39310 {
39311 PyThreadState* __tstate = wxPyBeginAllowThreads();
39312 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 resultobj = SWIG_From_int(static_cast< int >(result));
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39324 PyObject *resultobj = 0;
39325 wxWindow *arg1 = (wxWindow *) 0 ;
39326 wxBorder result;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329
39330 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39332 if (!SWIG_IsOK(res1)) {
39333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39334 }
39335 arg1 = reinterpret_cast< wxWindow * >(argp1);
39336 {
39337 PyThreadState* __tstate = wxPyBeginAllowThreads();
39338 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39339 wxPyEndAllowThreads(__tstate);
39340 if (PyErr_Occurred()) SWIG_fail;
39341 }
39342 resultobj = SWIG_From_int(static_cast< int >(result));
39343 return resultobj;
39344 fail:
39345 return NULL;
39346 }
39347
39348
39349 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39350 int argc;
39351 PyObject *argv[3];
39352
39353 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39354 --argc;
39355 if (argc == 1) {
39356 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39357 }
39358 if (argc == 2) {
39359 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39360 }
39361
39362 fail:
39363 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39364 return NULL;
39365 }
39366
39367
39368 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj = 0;
39370 wxWindow *arg1 = (wxWindow *) 0 ;
39371 long arg2 = (long) wxUPDATE_UI_NONE ;
39372 void *argp1 = 0 ;
39373 int res1 = 0 ;
39374 long val2 ;
39375 int ecode2 = 0 ;
39376 PyObject * obj0 = 0 ;
39377 PyObject * obj1 = 0 ;
39378 char * kwnames[] = {
39379 (char *) "self",(char *) "flags", NULL
39380 };
39381
39382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39384 if (!SWIG_IsOK(res1)) {
39385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39386 }
39387 arg1 = reinterpret_cast< wxWindow * >(argp1);
39388 if (obj1) {
39389 ecode2 = SWIG_AsVal_long(obj1, &val2);
39390 if (!SWIG_IsOK(ecode2)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39392 }
39393 arg2 = static_cast< long >(val2);
39394 }
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 (arg1)->UpdateWindowUI(arg2);
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 resultobj = SWIG_Py_Void();
39402 return resultobj;
39403 fail:
39404 return NULL;
39405 }
39406
39407
39408 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39409 PyObject *resultobj = 0;
39410 wxWindow *arg1 = (wxWindow *) 0 ;
39411 wxMenu *arg2 = (wxMenu *) 0 ;
39412 int arg3 = (int) -1 ;
39413 int arg4 = (int) -1 ;
39414 bool result;
39415 void *argp1 = 0 ;
39416 int res1 = 0 ;
39417 void *argp2 = 0 ;
39418 int res2 = 0 ;
39419 int val3 ;
39420 int ecode3 = 0 ;
39421 int val4 ;
39422 int ecode4 = 0 ;
39423 PyObject * obj0 = 0 ;
39424 PyObject * obj1 = 0 ;
39425 PyObject * obj2 = 0 ;
39426 PyObject * obj3 = 0 ;
39427 char * kwnames[] = {
39428 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39429 };
39430
39431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39433 if (!SWIG_IsOK(res1)) {
39434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39435 }
39436 arg1 = reinterpret_cast< wxWindow * >(argp1);
39437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39438 if (!SWIG_IsOK(res2)) {
39439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39440 }
39441 arg2 = reinterpret_cast< wxMenu * >(argp2);
39442 if (obj2) {
39443 ecode3 = SWIG_AsVal_int(obj2, &val3);
39444 if (!SWIG_IsOK(ecode3)) {
39445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39446 }
39447 arg3 = static_cast< int >(val3);
39448 }
39449 if (obj3) {
39450 ecode4 = SWIG_AsVal_int(obj3, &val4);
39451 if (!SWIG_IsOK(ecode4)) {
39452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39453 }
39454 arg4 = static_cast< int >(val4);
39455 }
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 {
39463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39464 }
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj = 0;
39473 wxWindow *arg1 = (wxWindow *) 0 ;
39474 wxMenu *arg2 = (wxMenu *) 0 ;
39475 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39476 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39477 bool result;
39478 void *argp1 = 0 ;
39479 int res1 = 0 ;
39480 void *argp2 = 0 ;
39481 int res2 = 0 ;
39482 wxPoint temp3 ;
39483 PyObject * obj0 = 0 ;
39484 PyObject * obj1 = 0 ;
39485 PyObject * obj2 = 0 ;
39486 char * kwnames[] = {
39487 (char *) "self",(char *) "menu",(char *) "pos", NULL
39488 };
39489
39490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39492 if (!SWIG_IsOK(res1)) {
39493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39494 }
39495 arg1 = reinterpret_cast< wxWindow * >(argp1);
39496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39497 if (!SWIG_IsOK(res2)) {
39498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39499 }
39500 arg2 = reinterpret_cast< wxMenu * >(argp2);
39501 if (obj2) {
39502 {
39503 arg3 = &temp3;
39504 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39505 }
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 {
39514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39515 }
39516 return resultobj;
39517 fail:
39518 return NULL;
39519 }
39520
39521
39522 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39523 PyObject *resultobj = 0;
39524 wxWindow *arg1 = (wxWindow *) 0 ;
39525 bool result;
39526 void *argp1 = 0 ;
39527 int res1 = 0 ;
39528 PyObject *swig_obj[1] ;
39529
39530 if (!args) SWIG_fail;
39531 swig_obj[0] = args;
39532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39533 if (!SWIG_IsOK(res1)) {
39534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39535 }
39536 arg1 = reinterpret_cast< wxWindow * >(argp1);
39537 {
39538 PyThreadState* __tstate = wxPyBeginAllowThreads();
39539 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 {
39544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39545 }
39546 return resultobj;
39547 fail:
39548 return NULL;
39549 }
39550
39551
39552 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39553 PyObject *resultobj = 0;
39554 wxWindow *arg1 = (wxWindow *) 0 ;
39555 long result;
39556 void *argp1 = 0 ;
39557 int res1 = 0 ;
39558 PyObject *swig_obj[1] ;
39559
39560 if (!args) SWIG_fail;
39561 swig_obj[0] = args;
39562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39563 if (!SWIG_IsOK(res1)) {
39564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39565 }
39566 arg1 = reinterpret_cast< wxWindow * >(argp1);
39567 {
39568 PyThreadState* __tstate = wxPyBeginAllowThreads();
39569 result = (long)wxWindow_GetHandle(arg1);
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 resultobj = SWIG_From_long(static_cast< long >(result));
39574 return resultobj;
39575 fail:
39576 return NULL;
39577 }
39578
39579
39580 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39581 PyObject *resultobj = 0;
39582 wxWindow *arg1 = (wxWindow *) 0 ;
39583 long arg2 ;
39584 void *argp1 = 0 ;
39585 int res1 = 0 ;
39586 long val2 ;
39587 int ecode2 = 0 ;
39588 PyObject * obj0 = 0 ;
39589 PyObject * obj1 = 0 ;
39590 char * kwnames[] = {
39591 (char *) "self",(char *) "handle", NULL
39592 };
39593
39594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39598 }
39599 arg1 = reinterpret_cast< wxWindow * >(argp1);
39600 ecode2 = SWIG_AsVal_long(obj1, &val2);
39601 if (!SWIG_IsOK(ecode2)) {
39602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39603 }
39604 arg2 = static_cast< long >(val2);
39605 {
39606 PyThreadState* __tstate = wxPyBeginAllowThreads();
39607 wxWindow_AssociateHandle(arg1,arg2);
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 resultobj = SWIG_Py_Void();
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39619 PyObject *resultobj = 0;
39620 wxWindow *arg1 = (wxWindow *) 0 ;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 PyObject *swig_obj[1] ;
39624
39625 if (!args) SWIG_fail;
39626 swig_obj[0] = args;
39627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39630 }
39631 arg1 = reinterpret_cast< wxWindow * >(argp1);
39632 {
39633 PyThreadState* __tstate = wxPyBeginAllowThreads();
39634 (arg1)->DissociateHandle();
39635 wxPyEndAllowThreads(__tstate);
39636 if (PyErr_Occurred()) SWIG_fail;
39637 }
39638 resultobj = SWIG_Py_Void();
39639 return resultobj;
39640 fail:
39641 return NULL;
39642 }
39643
39644
39645 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39646 PyObject *resultobj = 0;
39647 wxWindow *arg1 = (wxWindow *) 0 ;
39648 int arg2 ;
39649 bool result;
39650 void *argp1 = 0 ;
39651 int res1 = 0 ;
39652 int val2 ;
39653 int ecode2 = 0 ;
39654 PyObject * obj0 = 0 ;
39655 PyObject * obj1 = 0 ;
39656 char * kwnames[] = {
39657 (char *) "self",(char *) "orient", NULL
39658 };
39659
39660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39662 if (!SWIG_IsOK(res1)) {
39663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39664 }
39665 arg1 = reinterpret_cast< wxWindow * >(argp1);
39666 ecode2 = SWIG_AsVal_int(obj1, &val2);
39667 if (!SWIG_IsOK(ecode2)) {
39668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39669 }
39670 arg2 = static_cast< int >(val2);
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39674 wxPyEndAllowThreads(__tstate);
39675 if (PyErr_Occurred()) SWIG_fail;
39676 }
39677 {
39678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39679 }
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj = 0;
39688 wxWindow *arg1 = (wxWindow *) 0 ;
39689 int arg2 ;
39690 int arg3 ;
39691 int arg4 ;
39692 int arg5 ;
39693 bool arg6 = (bool) true ;
39694 void *argp1 = 0 ;
39695 int res1 = 0 ;
39696 int val2 ;
39697 int ecode2 = 0 ;
39698 int val3 ;
39699 int ecode3 = 0 ;
39700 int val4 ;
39701 int ecode4 = 0 ;
39702 int val5 ;
39703 int ecode5 = 0 ;
39704 bool val6 ;
39705 int ecode6 = 0 ;
39706 PyObject * obj0 = 0 ;
39707 PyObject * obj1 = 0 ;
39708 PyObject * obj2 = 0 ;
39709 PyObject * obj3 = 0 ;
39710 PyObject * obj4 = 0 ;
39711 PyObject * obj5 = 0 ;
39712 char * kwnames[] = {
39713 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39714 };
39715
39716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39718 if (!SWIG_IsOK(res1)) {
39719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39720 }
39721 arg1 = reinterpret_cast< wxWindow * >(argp1);
39722 ecode2 = SWIG_AsVal_int(obj1, &val2);
39723 if (!SWIG_IsOK(ecode2)) {
39724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39725 }
39726 arg2 = static_cast< int >(val2);
39727 ecode3 = SWIG_AsVal_int(obj2, &val3);
39728 if (!SWIG_IsOK(ecode3)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39730 }
39731 arg3 = static_cast< int >(val3);
39732 ecode4 = SWIG_AsVal_int(obj3, &val4);
39733 if (!SWIG_IsOK(ecode4)) {
39734 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39735 }
39736 arg4 = static_cast< int >(val4);
39737 ecode5 = SWIG_AsVal_int(obj4, &val5);
39738 if (!SWIG_IsOK(ecode5)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39740 }
39741 arg5 = static_cast< int >(val5);
39742 if (obj5) {
39743 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39744 if (!SWIG_IsOK(ecode6)) {
39745 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39746 }
39747 arg6 = static_cast< bool >(val6);
39748 }
39749 {
39750 PyThreadState* __tstate = wxPyBeginAllowThreads();
39751 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39752 wxPyEndAllowThreads(__tstate);
39753 if (PyErr_Occurred()) SWIG_fail;
39754 }
39755 resultobj = SWIG_Py_Void();
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = 0;
39764 wxWindow *arg1 = (wxWindow *) 0 ;
39765 int arg2 ;
39766 int arg3 ;
39767 bool arg4 = (bool) true ;
39768 void *argp1 = 0 ;
39769 int res1 = 0 ;
39770 int val2 ;
39771 int ecode2 = 0 ;
39772 int val3 ;
39773 int ecode3 = 0 ;
39774 bool val4 ;
39775 int ecode4 = 0 ;
39776 PyObject * obj0 = 0 ;
39777 PyObject * obj1 = 0 ;
39778 PyObject * obj2 = 0 ;
39779 PyObject * obj3 = 0 ;
39780 char * kwnames[] = {
39781 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39782 };
39783
39784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39786 if (!SWIG_IsOK(res1)) {
39787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39788 }
39789 arg1 = reinterpret_cast< wxWindow * >(argp1);
39790 ecode2 = SWIG_AsVal_int(obj1, &val2);
39791 if (!SWIG_IsOK(ecode2)) {
39792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39793 }
39794 arg2 = static_cast< int >(val2);
39795 ecode3 = SWIG_AsVal_int(obj2, &val3);
39796 if (!SWIG_IsOK(ecode3)) {
39797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39798 }
39799 arg3 = static_cast< int >(val3);
39800 if (obj3) {
39801 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39802 if (!SWIG_IsOK(ecode4)) {
39803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39804 }
39805 arg4 = static_cast< bool >(val4);
39806 }
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 (arg1)->SetScrollPos(arg2,arg3,arg4);
39810 wxPyEndAllowThreads(__tstate);
39811 if (PyErr_Occurred()) SWIG_fail;
39812 }
39813 resultobj = SWIG_Py_Void();
39814 return resultobj;
39815 fail:
39816 return NULL;
39817 }
39818
39819
39820 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39821 PyObject *resultobj = 0;
39822 wxWindow *arg1 = (wxWindow *) 0 ;
39823 int arg2 ;
39824 int result;
39825 void *argp1 = 0 ;
39826 int res1 = 0 ;
39827 int val2 ;
39828 int ecode2 = 0 ;
39829 PyObject * obj0 = 0 ;
39830 PyObject * obj1 = 0 ;
39831 char * kwnames[] = {
39832 (char *) "self",(char *) "orientation", NULL
39833 };
39834
39835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39837 if (!SWIG_IsOK(res1)) {
39838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39839 }
39840 arg1 = reinterpret_cast< wxWindow * >(argp1);
39841 ecode2 = SWIG_AsVal_int(obj1, &val2);
39842 if (!SWIG_IsOK(ecode2)) {
39843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39844 }
39845 arg2 = static_cast< int >(val2);
39846 {
39847 PyThreadState* __tstate = wxPyBeginAllowThreads();
39848 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 resultobj = SWIG_From_int(static_cast< int >(result));
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj = 0;
39861 wxWindow *arg1 = (wxWindow *) 0 ;
39862 int arg2 ;
39863 int result;
39864 void *argp1 = 0 ;
39865 int res1 = 0 ;
39866 int val2 ;
39867 int ecode2 = 0 ;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 char * kwnames[] = {
39871 (char *) "self",(char *) "orientation", NULL
39872 };
39873
39874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39876 if (!SWIG_IsOK(res1)) {
39877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39878 }
39879 arg1 = reinterpret_cast< wxWindow * >(argp1);
39880 ecode2 = SWIG_AsVal_int(obj1, &val2);
39881 if (!SWIG_IsOK(ecode2)) {
39882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39883 }
39884 arg2 = static_cast< int >(val2);
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 resultobj = SWIG_From_int(static_cast< int >(result));
39892 return resultobj;
39893 fail:
39894 return NULL;
39895 }
39896
39897
39898 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj = 0;
39900 wxWindow *arg1 = (wxWindow *) 0 ;
39901 int arg2 ;
39902 int result;
39903 void *argp1 = 0 ;
39904 int res1 = 0 ;
39905 int val2 ;
39906 int ecode2 = 0 ;
39907 PyObject * obj0 = 0 ;
39908 PyObject * obj1 = 0 ;
39909 char * kwnames[] = {
39910 (char *) "self",(char *) "orientation", NULL
39911 };
39912
39913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39915 if (!SWIG_IsOK(res1)) {
39916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39917 }
39918 arg1 = reinterpret_cast< wxWindow * >(argp1);
39919 ecode2 = SWIG_AsVal_int(obj1, &val2);
39920 if (!SWIG_IsOK(ecode2)) {
39921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39922 }
39923 arg2 = static_cast< int >(val2);
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 resultobj = SWIG_From_int(static_cast< int >(result));
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj = 0;
39939 wxWindow *arg1 = (wxWindow *) 0 ;
39940 int arg2 ;
39941 int arg3 ;
39942 wxRect *arg4 = (wxRect *) NULL ;
39943 void *argp1 = 0 ;
39944 int res1 = 0 ;
39945 int val2 ;
39946 int ecode2 = 0 ;
39947 int val3 ;
39948 int ecode3 = 0 ;
39949 void *argp4 = 0 ;
39950 int res4 = 0 ;
39951 PyObject * obj0 = 0 ;
39952 PyObject * obj1 = 0 ;
39953 PyObject * obj2 = 0 ;
39954 PyObject * obj3 = 0 ;
39955 char * kwnames[] = {
39956 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39957 };
39958
39959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39961 if (!SWIG_IsOK(res1)) {
39962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39963 }
39964 arg1 = reinterpret_cast< wxWindow * >(argp1);
39965 ecode2 = SWIG_AsVal_int(obj1, &val2);
39966 if (!SWIG_IsOK(ecode2)) {
39967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39968 }
39969 arg2 = static_cast< int >(val2);
39970 ecode3 = SWIG_AsVal_int(obj2, &val3);
39971 if (!SWIG_IsOK(ecode3)) {
39972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39973 }
39974 arg3 = static_cast< int >(val3);
39975 if (obj3) {
39976 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39977 if (!SWIG_IsOK(res4)) {
39978 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39979 }
39980 arg4 = reinterpret_cast< wxRect * >(argp4);
39981 }
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39985 wxPyEndAllowThreads(__tstate);
39986 if (PyErr_Occurred()) SWIG_fail;
39987 }
39988 resultobj = SWIG_Py_Void();
39989 return resultobj;
39990 fail:
39991 return NULL;
39992 }
39993
39994
39995 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39996 PyObject *resultobj = 0;
39997 wxWindow *arg1 = (wxWindow *) 0 ;
39998 int arg2 ;
39999 bool result;
40000 void *argp1 = 0 ;
40001 int res1 = 0 ;
40002 int val2 ;
40003 int ecode2 = 0 ;
40004 PyObject * obj0 = 0 ;
40005 PyObject * obj1 = 0 ;
40006 char * kwnames[] = {
40007 (char *) "self",(char *) "lines", NULL
40008 };
40009
40010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40012 if (!SWIG_IsOK(res1)) {
40013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40014 }
40015 arg1 = reinterpret_cast< wxWindow * >(argp1);
40016 ecode2 = SWIG_AsVal_int(obj1, &val2);
40017 if (!SWIG_IsOK(ecode2)) {
40018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40019 }
40020 arg2 = static_cast< int >(val2);
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (bool)(arg1)->ScrollLines(arg2);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 {
40028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40029 }
40030 return resultobj;
40031 fail:
40032 return NULL;
40033 }
40034
40035
40036 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40037 PyObject *resultobj = 0;
40038 wxWindow *arg1 = (wxWindow *) 0 ;
40039 int arg2 ;
40040 bool result;
40041 void *argp1 = 0 ;
40042 int res1 = 0 ;
40043 int val2 ;
40044 int ecode2 = 0 ;
40045 PyObject * obj0 = 0 ;
40046 PyObject * obj1 = 0 ;
40047 char * kwnames[] = {
40048 (char *) "self",(char *) "pages", NULL
40049 };
40050
40051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40055 }
40056 arg1 = reinterpret_cast< wxWindow * >(argp1);
40057 ecode2 = SWIG_AsVal_int(obj1, &val2);
40058 if (!SWIG_IsOK(ecode2)) {
40059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40060 }
40061 arg2 = static_cast< int >(val2);
40062 {
40063 PyThreadState* __tstate = wxPyBeginAllowThreads();
40064 result = (bool)(arg1)->ScrollPages(arg2);
40065 wxPyEndAllowThreads(__tstate);
40066 if (PyErr_Occurred()) SWIG_fail;
40067 }
40068 {
40069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40070 }
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40078 PyObject *resultobj = 0;
40079 wxWindow *arg1 = (wxWindow *) 0 ;
40080 bool result;
40081 void *argp1 = 0 ;
40082 int res1 = 0 ;
40083 PyObject *swig_obj[1] ;
40084
40085 if (!args) SWIG_fail;
40086 swig_obj[0] = args;
40087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40088 if (!SWIG_IsOK(res1)) {
40089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40090 }
40091 arg1 = reinterpret_cast< wxWindow * >(argp1);
40092 {
40093 PyThreadState* __tstate = wxPyBeginAllowThreads();
40094 result = (bool)(arg1)->LineUp();
40095 wxPyEndAllowThreads(__tstate);
40096 if (PyErr_Occurred()) SWIG_fail;
40097 }
40098 {
40099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40100 }
40101 return resultobj;
40102 fail:
40103 return NULL;
40104 }
40105
40106
40107 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40108 PyObject *resultobj = 0;
40109 wxWindow *arg1 = (wxWindow *) 0 ;
40110 bool result;
40111 void *argp1 = 0 ;
40112 int res1 = 0 ;
40113 PyObject *swig_obj[1] ;
40114
40115 if (!args) SWIG_fail;
40116 swig_obj[0] = args;
40117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40118 if (!SWIG_IsOK(res1)) {
40119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40120 }
40121 arg1 = reinterpret_cast< wxWindow * >(argp1);
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 result = (bool)(arg1)->LineDown();
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 {
40129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40130 }
40131 return resultobj;
40132 fail:
40133 return NULL;
40134 }
40135
40136
40137 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40138 PyObject *resultobj = 0;
40139 wxWindow *arg1 = (wxWindow *) 0 ;
40140 bool result;
40141 void *argp1 = 0 ;
40142 int res1 = 0 ;
40143 PyObject *swig_obj[1] ;
40144
40145 if (!args) SWIG_fail;
40146 swig_obj[0] = args;
40147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40148 if (!SWIG_IsOK(res1)) {
40149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40150 }
40151 arg1 = reinterpret_cast< wxWindow * >(argp1);
40152 {
40153 PyThreadState* __tstate = wxPyBeginAllowThreads();
40154 result = (bool)(arg1)->PageUp();
40155 wxPyEndAllowThreads(__tstate);
40156 if (PyErr_Occurred()) SWIG_fail;
40157 }
40158 {
40159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40160 }
40161 return resultobj;
40162 fail:
40163 return NULL;
40164 }
40165
40166
40167 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40168 PyObject *resultobj = 0;
40169 wxWindow *arg1 = (wxWindow *) 0 ;
40170 bool result;
40171 void *argp1 = 0 ;
40172 int res1 = 0 ;
40173 PyObject *swig_obj[1] ;
40174
40175 if (!args) SWIG_fail;
40176 swig_obj[0] = args;
40177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40178 if (!SWIG_IsOK(res1)) {
40179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40180 }
40181 arg1 = reinterpret_cast< wxWindow * >(argp1);
40182 {
40183 PyThreadState* __tstate = wxPyBeginAllowThreads();
40184 result = (bool)(arg1)->PageDown();
40185 wxPyEndAllowThreads(__tstate);
40186 if (PyErr_Occurred()) SWIG_fail;
40187 }
40188 {
40189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40190 }
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = 0;
40199 wxWindow *arg1 = (wxWindow *) 0 ;
40200 wxString *arg2 = 0 ;
40201 void *argp1 = 0 ;
40202 int res1 = 0 ;
40203 bool temp2 = false ;
40204 PyObject * obj0 = 0 ;
40205 PyObject * obj1 = 0 ;
40206 char * kwnames[] = {
40207 (char *) "self",(char *) "text", NULL
40208 };
40209
40210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40212 if (!SWIG_IsOK(res1)) {
40213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40214 }
40215 arg1 = reinterpret_cast< wxWindow * >(argp1);
40216 {
40217 arg2 = wxString_in_helper(obj1);
40218 if (arg2 == NULL) SWIG_fail;
40219 temp2 = true;
40220 }
40221 {
40222 PyThreadState* __tstate = wxPyBeginAllowThreads();
40223 (arg1)->SetHelpText((wxString const &)*arg2);
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 resultobj = SWIG_Py_Void();
40228 {
40229 if (temp2)
40230 delete arg2;
40231 }
40232 return resultobj;
40233 fail:
40234 {
40235 if (temp2)
40236 delete arg2;
40237 }
40238 return NULL;
40239 }
40240
40241
40242 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40243 PyObject *resultobj = 0;
40244 wxWindow *arg1 = (wxWindow *) 0 ;
40245 wxString *arg2 = 0 ;
40246 void *argp1 = 0 ;
40247 int res1 = 0 ;
40248 bool temp2 = false ;
40249 PyObject * obj0 = 0 ;
40250 PyObject * obj1 = 0 ;
40251 char * kwnames[] = {
40252 (char *) "self",(char *) "text", NULL
40253 };
40254
40255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40257 if (!SWIG_IsOK(res1)) {
40258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40259 }
40260 arg1 = reinterpret_cast< wxWindow * >(argp1);
40261 {
40262 arg2 = wxString_in_helper(obj1);
40263 if (arg2 == NULL) SWIG_fail;
40264 temp2 = true;
40265 }
40266 {
40267 PyThreadState* __tstate = wxPyBeginAllowThreads();
40268 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 resultobj = SWIG_Py_Void();
40273 {
40274 if (temp2)
40275 delete arg2;
40276 }
40277 return resultobj;
40278 fail:
40279 {
40280 if (temp2)
40281 delete arg2;
40282 }
40283 return NULL;
40284 }
40285
40286
40287 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40288 PyObject *resultobj = 0;
40289 wxWindow *arg1 = (wxWindow *) 0 ;
40290 wxPoint *arg2 = 0 ;
40291 wxHelpEvent::Origin arg3 ;
40292 wxString result;
40293 void *argp1 = 0 ;
40294 int res1 = 0 ;
40295 wxPoint temp2 ;
40296 void *argp3 ;
40297 int res3 = 0 ;
40298 PyObject * obj0 = 0 ;
40299 PyObject * obj1 = 0 ;
40300 PyObject * obj2 = 0 ;
40301 char * kwnames[] = {
40302 (char *) "self",(char *) "pt",(char *) "origin", NULL
40303 };
40304
40305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40307 if (!SWIG_IsOK(res1)) {
40308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40309 }
40310 arg1 = reinterpret_cast< wxWindow * >(argp1);
40311 {
40312 arg2 = &temp2;
40313 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40314 }
40315 {
40316 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40317 if (!SWIG_IsOK(res3)) {
40318 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40319 }
40320 if (!argp3) {
40321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40322 } else {
40323 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40324 arg3 = *temp;
40325 if (SWIG_IsNewObj(res3)) delete temp;
40326 }
40327 }
40328 {
40329 PyThreadState* __tstate = wxPyBeginAllowThreads();
40330 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40331 wxPyEndAllowThreads(__tstate);
40332 if (PyErr_Occurred()) SWIG_fail;
40333 }
40334 {
40335 #if wxUSE_UNICODE
40336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40337 #else
40338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40339 #endif
40340 }
40341 return resultobj;
40342 fail:
40343 return NULL;
40344 }
40345
40346
40347 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40348 PyObject *resultobj = 0;
40349 wxWindow *arg1 = (wxWindow *) 0 ;
40350 wxString result;
40351 void *argp1 = 0 ;
40352 int res1 = 0 ;
40353 PyObject *swig_obj[1] ;
40354
40355 if (!args) SWIG_fail;
40356 swig_obj[0] = args;
40357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40358 if (!SWIG_IsOK(res1)) {
40359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40360 }
40361 arg1 = reinterpret_cast< wxWindow * >(argp1);
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 result = ((wxWindow const *)arg1)->GetHelpText();
40365 wxPyEndAllowThreads(__tstate);
40366 if (PyErr_Occurred()) SWIG_fail;
40367 }
40368 {
40369 #if wxUSE_UNICODE
40370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40371 #else
40372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40373 #endif
40374 }
40375 return resultobj;
40376 fail:
40377 return NULL;
40378 }
40379
40380
40381 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40382 PyObject *resultobj = 0;
40383 wxWindow *arg1 = (wxWindow *) 0 ;
40384 wxString *arg2 = 0 ;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 bool temp2 = false ;
40388 PyObject * obj0 = 0 ;
40389 PyObject * obj1 = 0 ;
40390 char * kwnames[] = {
40391 (char *) "self",(char *) "tip", NULL
40392 };
40393
40394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40396 if (!SWIG_IsOK(res1)) {
40397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40398 }
40399 arg1 = reinterpret_cast< wxWindow * >(argp1);
40400 {
40401 arg2 = wxString_in_helper(obj1);
40402 if (arg2 == NULL) SWIG_fail;
40403 temp2 = true;
40404 }
40405 {
40406 PyThreadState* __tstate = wxPyBeginAllowThreads();
40407 (arg1)->SetToolTip((wxString const &)*arg2);
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 resultobj = SWIG_Py_Void();
40412 {
40413 if (temp2)
40414 delete arg2;
40415 }
40416 return resultobj;
40417 fail:
40418 {
40419 if (temp2)
40420 delete arg2;
40421 }
40422 return NULL;
40423 }
40424
40425
40426 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj = 0;
40428 wxWindow *arg1 = (wxWindow *) 0 ;
40429 wxToolTip *arg2 = (wxToolTip *) 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 int res2 = 0 ;
40433 PyObject * obj0 = 0 ;
40434 PyObject * obj1 = 0 ;
40435 char * kwnames[] = {
40436 (char *) "self",(char *) "tip", NULL
40437 };
40438
40439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40441 if (!SWIG_IsOK(res1)) {
40442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40443 }
40444 arg1 = reinterpret_cast< wxWindow * >(argp1);
40445 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40446 if (!SWIG_IsOK(res2)) {
40447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40448 }
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 (arg1)->SetToolTip(arg2);
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 resultobj = SWIG_Py_Void();
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40463 PyObject *resultobj = 0;
40464 wxWindow *arg1 = (wxWindow *) 0 ;
40465 wxToolTip *result = 0 ;
40466 void *argp1 = 0 ;
40467 int res1 = 0 ;
40468 PyObject *swig_obj[1] ;
40469
40470 if (!args) SWIG_fail;
40471 swig_obj[0] = args;
40472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40473 if (!SWIG_IsOK(res1)) {
40474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40475 }
40476 arg1 = reinterpret_cast< wxWindow * >(argp1);
40477 {
40478 PyThreadState* __tstate = wxPyBeginAllowThreads();
40479 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 {
40484 resultobj = wxPyMake_wxObject(result, (bool)0);
40485 }
40486 return resultobj;
40487 fail:
40488 return NULL;
40489 }
40490
40491
40492 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40493 PyObject *resultobj = 0;
40494 wxWindow *arg1 = (wxWindow *) 0 ;
40495 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40496 void *argp1 = 0 ;
40497 int res1 = 0 ;
40498 int res2 = 0 ;
40499 PyObject * obj0 = 0 ;
40500 PyObject * obj1 = 0 ;
40501 char * kwnames[] = {
40502 (char *) "self",(char *) "dropTarget", NULL
40503 };
40504
40505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40507 if (!SWIG_IsOK(res1)) {
40508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40509 }
40510 arg1 = reinterpret_cast< wxWindow * >(argp1);
40511 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40512 if (!SWIG_IsOK(res2)) {
40513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40514 }
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 (arg1)->SetDropTarget(arg2);
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 resultobj = SWIG_Py_Void();
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40529 PyObject *resultobj = 0;
40530 wxWindow *arg1 = (wxWindow *) 0 ;
40531 wxPyDropTarget *result = 0 ;
40532 void *argp1 = 0 ;
40533 int res1 = 0 ;
40534 PyObject *swig_obj[1] ;
40535
40536 if (!args) SWIG_fail;
40537 swig_obj[0] = args;
40538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40539 if (!SWIG_IsOK(res1)) {
40540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40541 }
40542 arg1 = reinterpret_cast< wxWindow * >(argp1);
40543 {
40544 PyThreadState* __tstate = wxPyBeginAllowThreads();
40545 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40546 wxPyEndAllowThreads(__tstate);
40547 if (PyErr_Occurred()) SWIG_fail;
40548 }
40549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40550 return resultobj;
40551 fail:
40552 return NULL;
40553 }
40554
40555
40556 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40557 PyObject *resultobj = 0;
40558 wxWindow *arg1 = (wxWindow *) 0 ;
40559 bool arg2 ;
40560 void *argp1 = 0 ;
40561 int res1 = 0 ;
40562 bool val2 ;
40563 int ecode2 = 0 ;
40564 PyObject * obj0 = 0 ;
40565 PyObject * obj1 = 0 ;
40566 char * kwnames[] = {
40567 (char *) "self",(char *) "accept", NULL
40568 };
40569
40570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40572 if (!SWIG_IsOK(res1)) {
40573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40574 }
40575 arg1 = reinterpret_cast< wxWindow * >(argp1);
40576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40577 if (!SWIG_IsOK(ecode2)) {
40578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40579 }
40580 arg2 = static_cast< bool >(val2);
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 wxWindow_DragAcceptFiles(arg1,arg2);
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 resultobj = SWIG_Py_Void();
40588 return resultobj;
40589 fail:
40590 return NULL;
40591 }
40592
40593
40594 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40595 PyObject *resultobj = 0;
40596 wxWindow *arg1 = (wxWindow *) 0 ;
40597 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40598 void *argp1 = 0 ;
40599 int res1 = 0 ;
40600 int res2 = 0 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char * kwnames[] = {
40604 (char *) "self",(char *) "constraints", NULL
40605 };
40606
40607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40609 if (!SWIG_IsOK(res1)) {
40610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40611 }
40612 arg1 = reinterpret_cast< wxWindow * >(argp1);
40613 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40614 if (!SWIG_IsOK(res2)) {
40615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40616 }
40617 {
40618 PyThreadState* __tstate = wxPyBeginAllowThreads();
40619 (arg1)->SetConstraints(arg2);
40620 wxPyEndAllowThreads(__tstate);
40621 if (PyErr_Occurred()) SWIG_fail;
40622 }
40623 resultobj = SWIG_Py_Void();
40624 return resultobj;
40625 fail:
40626 return NULL;
40627 }
40628
40629
40630 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40631 PyObject *resultobj = 0;
40632 wxWindow *arg1 = (wxWindow *) 0 ;
40633 wxLayoutConstraints *result = 0 ;
40634 void *argp1 = 0 ;
40635 int res1 = 0 ;
40636 PyObject *swig_obj[1] ;
40637
40638 if (!args) SWIG_fail;
40639 swig_obj[0] = args;
40640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40641 if (!SWIG_IsOK(res1)) {
40642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40643 }
40644 arg1 = reinterpret_cast< wxWindow * >(argp1);
40645 {
40646 PyThreadState* __tstate = wxPyBeginAllowThreads();
40647 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40659 PyObject *resultobj = 0;
40660 wxWindow *arg1 = (wxWindow *) 0 ;
40661 bool arg2 ;
40662 void *argp1 = 0 ;
40663 int res1 = 0 ;
40664 bool val2 ;
40665 int ecode2 = 0 ;
40666 PyObject * obj0 = 0 ;
40667 PyObject * obj1 = 0 ;
40668 char * kwnames[] = {
40669 (char *) "self",(char *) "autoLayout", NULL
40670 };
40671
40672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40674 if (!SWIG_IsOK(res1)) {
40675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40676 }
40677 arg1 = reinterpret_cast< wxWindow * >(argp1);
40678 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40679 if (!SWIG_IsOK(ecode2)) {
40680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40681 }
40682 arg2 = static_cast< bool >(val2);
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 (arg1)->SetAutoLayout(arg2);
40686 wxPyEndAllowThreads(__tstate);
40687 if (PyErr_Occurred()) SWIG_fail;
40688 }
40689 resultobj = SWIG_Py_Void();
40690 return resultobj;
40691 fail:
40692 return NULL;
40693 }
40694
40695
40696 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40697 PyObject *resultobj = 0;
40698 wxWindow *arg1 = (wxWindow *) 0 ;
40699 bool result;
40700 void *argp1 = 0 ;
40701 int res1 = 0 ;
40702 PyObject *swig_obj[1] ;
40703
40704 if (!args) SWIG_fail;
40705 swig_obj[0] = args;
40706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40707 if (!SWIG_IsOK(res1)) {
40708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40709 }
40710 arg1 = reinterpret_cast< wxWindow * >(argp1);
40711 {
40712 PyThreadState* __tstate = wxPyBeginAllowThreads();
40713 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40714 wxPyEndAllowThreads(__tstate);
40715 if (PyErr_Occurred()) SWIG_fail;
40716 }
40717 {
40718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40719 }
40720 return resultobj;
40721 fail:
40722 return NULL;
40723 }
40724
40725
40726 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40727 PyObject *resultobj = 0;
40728 wxWindow *arg1 = (wxWindow *) 0 ;
40729 bool result;
40730 void *argp1 = 0 ;
40731 int res1 = 0 ;
40732 PyObject *swig_obj[1] ;
40733
40734 if (!args) SWIG_fail;
40735 swig_obj[0] = args;
40736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40737 if (!SWIG_IsOK(res1)) {
40738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40739 }
40740 arg1 = reinterpret_cast< wxWindow * >(argp1);
40741 {
40742 PyThreadState* __tstate = wxPyBeginAllowThreads();
40743 result = (bool)(arg1)->Layout();
40744 wxPyEndAllowThreads(__tstate);
40745 if (PyErr_Occurred()) SWIG_fail;
40746 }
40747 {
40748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40749 }
40750 return resultobj;
40751 fail:
40752 return NULL;
40753 }
40754
40755
40756 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40757 PyObject *resultobj = 0;
40758 wxWindow *arg1 = (wxWindow *) 0 ;
40759 wxSizer *arg2 = (wxSizer *) 0 ;
40760 bool arg3 = (bool) true ;
40761 void *argp1 = 0 ;
40762 int res1 = 0 ;
40763 int res2 = 0 ;
40764 bool val3 ;
40765 int ecode3 = 0 ;
40766 PyObject * obj0 = 0 ;
40767 PyObject * obj1 = 0 ;
40768 PyObject * obj2 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40777 }
40778 arg1 = reinterpret_cast< wxWindow * >(argp1);
40779 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40780 if (!SWIG_IsOK(res2)) {
40781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40782 }
40783 if (obj2) {
40784 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40785 if (!SWIG_IsOK(ecode3)) {
40786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40787 }
40788 arg3 = static_cast< bool >(val3);
40789 }
40790 {
40791 PyThreadState* __tstate = wxPyBeginAllowThreads();
40792 (arg1)->SetSizer(arg2,arg3);
40793 wxPyEndAllowThreads(__tstate);
40794 if (PyErr_Occurred()) SWIG_fail;
40795 }
40796 resultobj = SWIG_Py_Void();
40797 return resultobj;
40798 fail:
40799 return NULL;
40800 }
40801
40802
40803 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj = 0;
40805 wxWindow *arg1 = (wxWindow *) 0 ;
40806 wxSizer *arg2 = (wxSizer *) 0 ;
40807 bool arg3 = (bool) true ;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 int res2 = 0 ;
40811 bool val3 ;
40812 int ecode3 = 0 ;
40813 PyObject * obj0 = 0 ;
40814 PyObject * obj1 = 0 ;
40815 PyObject * obj2 = 0 ;
40816 char * kwnames[] = {
40817 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40818 };
40819
40820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40822 if (!SWIG_IsOK(res1)) {
40823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40824 }
40825 arg1 = reinterpret_cast< wxWindow * >(argp1);
40826 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40827 if (!SWIG_IsOK(res2)) {
40828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40829 }
40830 if (obj2) {
40831 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40832 if (!SWIG_IsOK(ecode3)) {
40833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40834 }
40835 arg3 = static_cast< bool >(val3);
40836 }
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->SetSizerAndFit(arg2,arg3);
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_Py_Void();
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40851 PyObject *resultobj = 0;
40852 wxWindow *arg1 = (wxWindow *) 0 ;
40853 wxSizer *result = 0 ;
40854 void *argp1 = 0 ;
40855 int res1 = 0 ;
40856 PyObject *swig_obj[1] ;
40857
40858 if (!args) SWIG_fail;
40859 swig_obj[0] = args;
40860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40861 if (!SWIG_IsOK(res1)) {
40862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40863 }
40864 arg1 = reinterpret_cast< wxWindow * >(argp1);
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 {
40872 resultobj = wxPyMake_wxObject(result, (bool)0);
40873 }
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40881 PyObject *resultobj = 0;
40882 wxWindow *arg1 = (wxWindow *) 0 ;
40883 wxSizer *arg2 = (wxSizer *) 0 ;
40884 void *argp1 = 0 ;
40885 int res1 = 0 ;
40886 void *argp2 = 0 ;
40887 int res2 = 0 ;
40888 PyObject * obj0 = 0 ;
40889 PyObject * obj1 = 0 ;
40890 char * kwnames[] = {
40891 (char *) "self",(char *) "sizer", NULL
40892 };
40893
40894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40896 if (!SWIG_IsOK(res1)) {
40897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40898 }
40899 arg1 = reinterpret_cast< wxWindow * >(argp1);
40900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40901 if (!SWIG_IsOK(res2)) {
40902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40903 }
40904 arg2 = reinterpret_cast< wxSizer * >(argp2);
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 (arg1)->SetContainingSizer(arg2);
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 resultobj = SWIG_Py_Void();
40912 return resultobj;
40913 fail:
40914 return NULL;
40915 }
40916
40917
40918 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40919 PyObject *resultobj = 0;
40920 wxWindow *arg1 = (wxWindow *) 0 ;
40921 wxSizer *result = 0 ;
40922 void *argp1 = 0 ;
40923 int res1 = 0 ;
40924 PyObject *swig_obj[1] ;
40925
40926 if (!args) SWIG_fail;
40927 swig_obj[0] = args;
40928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40929 if (!SWIG_IsOK(res1)) {
40930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40931 }
40932 arg1 = reinterpret_cast< wxWindow * >(argp1);
40933 {
40934 PyThreadState* __tstate = wxPyBeginAllowThreads();
40935 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40936 wxPyEndAllowThreads(__tstate);
40937 if (PyErr_Occurred()) SWIG_fail;
40938 }
40939 {
40940 resultobj = wxPyMake_wxObject(result, (bool)0);
40941 }
40942 return resultobj;
40943 fail:
40944 return NULL;
40945 }
40946
40947
40948 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40949 PyObject *resultobj = 0;
40950 wxWindow *arg1 = (wxWindow *) 0 ;
40951 void *argp1 = 0 ;
40952 int res1 = 0 ;
40953 PyObject *swig_obj[1] ;
40954
40955 if (!args) SWIG_fail;
40956 swig_obj[0] = args;
40957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40958 if (!SWIG_IsOK(res1)) {
40959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40960 }
40961 arg1 = reinterpret_cast< wxWindow * >(argp1);
40962 {
40963 PyThreadState* __tstate = wxPyBeginAllowThreads();
40964 (arg1)->InheritAttributes();
40965 wxPyEndAllowThreads(__tstate);
40966 if (PyErr_Occurred()) SWIG_fail;
40967 }
40968 resultobj = SWIG_Py_Void();
40969 return resultobj;
40970 fail:
40971 return NULL;
40972 }
40973
40974
40975 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40976 PyObject *resultobj = 0;
40977 wxWindow *arg1 = (wxWindow *) 0 ;
40978 bool result;
40979 void *argp1 = 0 ;
40980 int res1 = 0 ;
40981 PyObject *swig_obj[1] ;
40982
40983 if (!args) SWIG_fail;
40984 swig_obj[0] = args;
40985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40986 if (!SWIG_IsOK(res1)) {
40987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40988 }
40989 arg1 = reinterpret_cast< wxWindow * >(argp1);
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 {
40997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40998 }
40999 return resultobj;
41000 fail:
41001 return NULL;
41002 }
41003
41004
41005 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41006 PyObject *resultobj = 0;
41007 wxWindow *arg1 = (wxWindow *) 0 ;
41008 bool result;
41009 void *argp1 = 0 ;
41010 int res1 = 0 ;
41011 PyObject *swig_obj[1] ;
41012
41013 if (!args) SWIG_fail;
41014 swig_obj[0] = args;
41015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41016 if (!SWIG_IsOK(res1)) {
41017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41018 }
41019 arg1 = reinterpret_cast< wxWindow * >(argp1);
41020 {
41021 PyThreadState* __tstate = wxPyBeginAllowThreads();
41022 result = (bool)(arg1)->CanSetTransparent();
41023 wxPyEndAllowThreads(__tstate);
41024 if (PyErr_Occurred()) SWIG_fail;
41025 }
41026 {
41027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41028 }
41029 return resultobj;
41030 fail:
41031 return NULL;
41032 }
41033
41034
41035 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41036 PyObject *resultobj = 0;
41037 wxWindow *arg1 = (wxWindow *) 0 ;
41038 byte arg2 ;
41039 bool result;
41040 void *argp1 = 0 ;
41041 int res1 = 0 ;
41042 unsigned char val2 ;
41043 int ecode2 = 0 ;
41044 PyObject * obj0 = 0 ;
41045 PyObject * obj1 = 0 ;
41046 char * kwnames[] = {
41047 (char *) "self",(char *) "alpha", NULL
41048 };
41049
41050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41052 if (!SWIG_IsOK(res1)) {
41053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41054 }
41055 arg1 = reinterpret_cast< wxWindow * >(argp1);
41056 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41057 if (!SWIG_IsOK(ecode2)) {
41058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41059 }
41060 arg2 = static_cast< byte >(val2);
41061 {
41062 PyThreadState* __tstate = wxPyBeginAllowThreads();
41063 result = (bool)(arg1)->SetTransparent(arg2);
41064 wxPyEndAllowThreads(__tstate);
41065 if (PyErr_Occurred()) SWIG_fail;
41066 }
41067 {
41068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41069 }
41070 return resultobj;
41071 fail:
41072 return NULL;
41073 }
41074
41075
41076 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41077 PyObject *obj;
41078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41079 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41080 return SWIG_Py_Void();
41081 }
41082
41083 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41084 return SWIG_Python_InitShadowInstance(args);
41085 }
41086
41087 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41088 PyObject *resultobj = 0;
41089 long arg1 ;
41090 wxWindow *arg2 = (wxWindow *) NULL ;
41091 wxWindow *result = 0 ;
41092 long val1 ;
41093 int ecode1 = 0 ;
41094 void *argp2 = 0 ;
41095 int res2 = 0 ;
41096 PyObject * obj0 = 0 ;
41097 PyObject * obj1 = 0 ;
41098 char * kwnames[] = {
41099 (char *) "id",(char *) "parent", NULL
41100 };
41101
41102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41103 ecode1 = SWIG_AsVal_long(obj0, &val1);
41104 if (!SWIG_IsOK(ecode1)) {
41105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41106 }
41107 arg1 = static_cast< long >(val1);
41108 if (obj1) {
41109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41110 if (!SWIG_IsOK(res2)) {
41111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41112 }
41113 arg2 = reinterpret_cast< wxWindow * >(argp2);
41114 }
41115 {
41116 if (!wxPyCheckForApp()) SWIG_fail;
41117 PyThreadState* __tstate = wxPyBeginAllowThreads();
41118 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41119 wxPyEndAllowThreads(__tstate);
41120 if (PyErr_Occurred()) SWIG_fail;
41121 }
41122 {
41123 resultobj = wxPyMake_wxObject(result, 0);
41124 }
41125 return resultobj;
41126 fail:
41127 return NULL;
41128 }
41129
41130
41131 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41132 PyObject *resultobj = 0;
41133 wxString *arg1 = 0 ;
41134 wxWindow *arg2 = (wxWindow *) NULL ;
41135 wxWindow *result = 0 ;
41136 bool temp1 = false ;
41137 void *argp2 = 0 ;
41138 int res2 = 0 ;
41139 PyObject * obj0 = 0 ;
41140 PyObject * obj1 = 0 ;
41141 char * kwnames[] = {
41142 (char *) "name",(char *) "parent", NULL
41143 };
41144
41145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41146 {
41147 arg1 = wxString_in_helper(obj0);
41148 if (arg1 == NULL) SWIG_fail;
41149 temp1 = true;
41150 }
41151 if (obj1) {
41152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41153 if (!SWIG_IsOK(res2)) {
41154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41155 }
41156 arg2 = reinterpret_cast< wxWindow * >(argp2);
41157 }
41158 {
41159 if (!wxPyCheckForApp()) SWIG_fail;
41160 PyThreadState* __tstate = wxPyBeginAllowThreads();
41161 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41162 wxPyEndAllowThreads(__tstate);
41163 if (PyErr_Occurred()) SWIG_fail;
41164 }
41165 {
41166 resultobj = wxPyMake_wxObject(result, 0);
41167 }
41168 {
41169 if (temp1)
41170 delete arg1;
41171 }
41172 return resultobj;
41173 fail:
41174 {
41175 if (temp1)
41176 delete arg1;
41177 }
41178 return NULL;
41179 }
41180
41181
41182 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41183 PyObject *resultobj = 0;
41184 wxString *arg1 = 0 ;
41185 wxWindow *arg2 = (wxWindow *) NULL ;
41186 wxWindow *result = 0 ;
41187 bool temp1 = false ;
41188 void *argp2 = 0 ;
41189 int res2 = 0 ;
41190 PyObject * obj0 = 0 ;
41191 PyObject * obj1 = 0 ;
41192 char * kwnames[] = {
41193 (char *) "label",(char *) "parent", NULL
41194 };
41195
41196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41197 {
41198 arg1 = wxString_in_helper(obj0);
41199 if (arg1 == NULL) SWIG_fail;
41200 temp1 = true;
41201 }
41202 if (obj1) {
41203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41204 if (!SWIG_IsOK(res2)) {
41205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41206 }
41207 arg2 = reinterpret_cast< wxWindow * >(argp2);
41208 }
41209 {
41210 if (!wxPyCheckForApp()) SWIG_fail;
41211 PyThreadState* __tstate = wxPyBeginAllowThreads();
41212 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41213 wxPyEndAllowThreads(__tstate);
41214 if (PyErr_Occurred()) SWIG_fail;
41215 }
41216 {
41217 resultobj = wxPyMake_wxObject(result, 0);
41218 }
41219 {
41220 if (temp1)
41221 delete arg1;
41222 }
41223 return resultobj;
41224 fail:
41225 {
41226 if (temp1)
41227 delete arg1;
41228 }
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = 0;
41235 wxWindow *arg1 = (wxWindow *) 0 ;
41236 unsigned long arg2 ;
41237 wxWindow *result = 0 ;
41238 void *argp1 = 0 ;
41239 int res1 = 0 ;
41240 unsigned long val2 ;
41241 int ecode2 = 0 ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "parent",(char *) "_hWnd", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41252 }
41253 arg1 = reinterpret_cast< wxWindow * >(argp1);
41254 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41255 if (!SWIG_IsOK(ecode2)) {
41256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41257 }
41258 arg2 = static_cast< unsigned long >(val2);
41259 {
41260 PyThreadState* __tstate = wxPyBeginAllowThreads();
41261 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41262 wxPyEndAllowThreads(__tstate);
41263 if (PyErr_Occurred()) SWIG_fail;
41264 }
41265 {
41266 resultobj = wxPyMake_wxObject(result, 0);
41267 }
41268 return resultobj;
41269 fail:
41270 return NULL;
41271 }
41272
41273
41274 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41275 PyObject *resultobj = 0;
41276 PyObject *result = 0 ;
41277
41278 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41279 {
41280 PyThreadState* __tstate = wxPyBeginAllowThreads();
41281 result = (PyObject *)GetTopLevelWindows();
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 resultobj = result;
41286 return resultobj;
41287 fail:
41288 return NULL;
41289 }
41290
41291
41292 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41293 PyObject *resultobj = 0;
41294 wxValidator *result = 0 ;
41295
41296 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 result = (wxValidator *)new wxValidator();
41300 wxPyEndAllowThreads(__tstate);
41301 if (PyErr_Occurred()) SWIG_fail;
41302 }
41303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41304 return resultobj;
41305 fail:
41306 return NULL;
41307 }
41308
41309
41310 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41311 PyObject *resultobj = 0;
41312 wxValidator *arg1 = (wxValidator *) 0 ;
41313 wxValidator *result = 0 ;
41314 void *argp1 = 0 ;
41315 int res1 = 0 ;
41316 PyObject *swig_obj[1] ;
41317
41318 if (!args) SWIG_fail;
41319 swig_obj[0] = args;
41320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41321 if (!SWIG_IsOK(res1)) {
41322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41323 }
41324 arg1 = reinterpret_cast< wxValidator * >(argp1);
41325 {
41326 PyThreadState* __tstate = wxPyBeginAllowThreads();
41327 result = (wxValidator *)(arg1)->Clone();
41328 wxPyEndAllowThreads(__tstate);
41329 if (PyErr_Occurred()) SWIG_fail;
41330 }
41331 {
41332 resultobj = wxPyMake_wxObject(result, 0);
41333 }
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj = 0;
41342 wxValidator *arg1 = (wxValidator *) 0 ;
41343 wxWindow *arg2 = (wxWindow *) 0 ;
41344 bool result;
41345 void *argp1 = 0 ;
41346 int res1 = 0 ;
41347 void *argp2 = 0 ;
41348 int res2 = 0 ;
41349 PyObject * obj0 = 0 ;
41350 PyObject * obj1 = 0 ;
41351 char * kwnames[] = {
41352 (char *) "self",(char *) "parent", NULL
41353 };
41354
41355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41357 if (!SWIG_IsOK(res1)) {
41358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41359 }
41360 arg1 = reinterpret_cast< wxValidator * >(argp1);
41361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41362 if (!SWIG_IsOK(res2)) {
41363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41364 }
41365 arg2 = reinterpret_cast< wxWindow * >(argp2);
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (bool)(arg1)->Validate(arg2);
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 {
41373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41374 }
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41382 PyObject *resultobj = 0;
41383 wxValidator *arg1 = (wxValidator *) 0 ;
41384 bool result;
41385 void *argp1 = 0 ;
41386 int res1 = 0 ;
41387 PyObject *swig_obj[1] ;
41388
41389 if (!args) SWIG_fail;
41390 swig_obj[0] = args;
41391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41392 if (!SWIG_IsOK(res1)) {
41393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41394 }
41395 arg1 = reinterpret_cast< wxValidator * >(argp1);
41396 {
41397 PyThreadState* __tstate = wxPyBeginAllowThreads();
41398 result = (bool)(arg1)->TransferToWindow();
41399 wxPyEndAllowThreads(__tstate);
41400 if (PyErr_Occurred()) SWIG_fail;
41401 }
41402 {
41403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41404 }
41405 return resultobj;
41406 fail:
41407 return NULL;
41408 }
41409
41410
41411 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41412 PyObject *resultobj = 0;
41413 wxValidator *arg1 = (wxValidator *) 0 ;
41414 bool result;
41415 void *argp1 = 0 ;
41416 int res1 = 0 ;
41417 PyObject *swig_obj[1] ;
41418
41419 if (!args) SWIG_fail;
41420 swig_obj[0] = args;
41421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41422 if (!SWIG_IsOK(res1)) {
41423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41424 }
41425 arg1 = reinterpret_cast< wxValidator * >(argp1);
41426 {
41427 PyThreadState* __tstate = wxPyBeginAllowThreads();
41428 result = (bool)(arg1)->TransferFromWindow();
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 {
41433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41434 }
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41442 PyObject *resultobj = 0;
41443 wxValidator *arg1 = (wxValidator *) 0 ;
41444 wxWindow *result = 0 ;
41445 void *argp1 = 0 ;
41446 int res1 = 0 ;
41447 PyObject *swig_obj[1] ;
41448
41449 if (!args) SWIG_fail;
41450 swig_obj[0] = args;
41451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41452 if (!SWIG_IsOK(res1)) {
41453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41454 }
41455 arg1 = reinterpret_cast< wxValidator * >(argp1);
41456 {
41457 PyThreadState* __tstate = wxPyBeginAllowThreads();
41458 result = (wxWindow *)(arg1)->GetWindow();
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 {
41463 resultobj = wxPyMake_wxObject(result, 0);
41464 }
41465 return resultobj;
41466 fail:
41467 return NULL;
41468 }
41469
41470
41471 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41472 PyObject *resultobj = 0;
41473 wxValidator *arg1 = (wxValidator *) 0 ;
41474 wxWindow *arg2 = (wxWindow *) 0 ;
41475 void *argp1 = 0 ;
41476 int res1 = 0 ;
41477 void *argp2 = 0 ;
41478 int res2 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 PyObject * obj1 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "self",(char *) "window", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41487 if (!SWIG_IsOK(res1)) {
41488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41489 }
41490 arg1 = reinterpret_cast< wxValidator * >(argp1);
41491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41492 if (!SWIG_IsOK(res2)) {
41493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41494 }
41495 arg2 = reinterpret_cast< wxWindow * >(argp2);
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 (arg1)->SetWindow(arg2);
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 resultobj = SWIG_Py_Void();
41503 return resultobj;
41504 fail:
41505 return NULL;
41506 }
41507
41508
41509 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41510 PyObject *resultobj = 0;
41511 bool result;
41512
41513 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (bool)wxValidator::IsSilent();
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 {
41521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41522 }
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj = 0;
41531 int arg1 = (int) true ;
41532 int val1 ;
41533 int ecode1 = 0 ;
41534 PyObject * obj0 = 0 ;
41535 char * kwnames[] = {
41536 (char *) "doIt", NULL
41537 };
41538
41539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41540 if (obj0) {
41541 ecode1 = SWIG_AsVal_int(obj0, &val1);
41542 if (!SWIG_IsOK(ecode1)) {
41543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41544 }
41545 arg1 = static_cast< int >(val1);
41546 }
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 wxValidator::SetBellOnError(arg1);
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 resultobj = SWIG_Py_Void();
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41561 PyObject *obj;
41562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41563 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41564 return SWIG_Py_Void();
41565 }
41566
41567 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41568 return SWIG_Python_InitShadowInstance(args);
41569 }
41570
41571 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41572 PyObject *resultobj = 0;
41573 wxPyValidator *result = 0 ;
41574
41575 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41576 {
41577 PyThreadState* __tstate = wxPyBeginAllowThreads();
41578 result = (wxPyValidator *)new wxPyValidator();
41579 wxPyEndAllowThreads(__tstate);
41580 if (PyErr_Occurred()) SWIG_fail;
41581 }
41582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41583 return resultobj;
41584 fail:
41585 return NULL;
41586 }
41587
41588
41589 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41590 PyObject *resultobj = 0;
41591 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41592 PyObject *arg2 = (PyObject *) 0 ;
41593 PyObject *arg3 = (PyObject *) 0 ;
41594 int arg4 = (int) true ;
41595 void *argp1 = 0 ;
41596 int res1 = 0 ;
41597 int val4 ;
41598 int ecode4 = 0 ;
41599 PyObject * obj0 = 0 ;
41600 PyObject * obj1 = 0 ;
41601 PyObject * obj2 = 0 ;
41602 PyObject * obj3 = 0 ;
41603 char * kwnames[] = {
41604 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41605 };
41606
41607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41609 if (!SWIG_IsOK(res1)) {
41610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41611 }
41612 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41613 arg2 = obj1;
41614 arg3 = obj2;
41615 if (obj3) {
41616 ecode4 = SWIG_AsVal_int(obj3, &val4);
41617 if (!SWIG_IsOK(ecode4)) {
41618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41619 }
41620 arg4 = static_cast< int >(val4);
41621 }
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41625 wxPyEndAllowThreads(__tstate);
41626 if (PyErr_Occurred()) SWIG_fail;
41627 }
41628 resultobj = SWIG_Py_Void();
41629 return resultobj;
41630 fail:
41631 return NULL;
41632 }
41633
41634
41635 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41636 PyObject *obj;
41637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41638 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41639 return SWIG_Py_Void();
41640 }
41641
41642 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41643 return SWIG_Python_InitShadowInstance(args);
41644 }
41645
41646 SWIGINTERN int DefaultValidator_set(PyObject *) {
41647 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41648 return 1;
41649 }
41650
41651
41652 SWIGINTERN PyObject *DefaultValidator_get(void) {
41653 PyObject *pyobj = 0;
41654
41655 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41656 return pyobj;
41657 }
41658
41659
41660 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41661 PyObject *resultobj = 0;
41662 wxString const &arg1_defvalue = wxPyEmptyString ;
41663 wxString *arg1 = (wxString *) &arg1_defvalue ;
41664 long arg2 = (long) 0 ;
41665 wxMenu *result = 0 ;
41666 bool temp1 = false ;
41667 long val2 ;
41668 int ecode2 = 0 ;
41669 PyObject * obj0 = 0 ;
41670 PyObject * obj1 = 0 ;
41671 char * kwnames[] = {
41672 (char *) "title",(char *) "style", NULL
41673 };
41674
41675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41676 if (obj0) {
41677 {
41678 arg1 = wxString_in_helper(obj0);
41679 if (arg1 == NULL) SWIG_fail;
41680 temp1 = true;
41681 }
41682 }
41683 if (obj1) {
41684 ecode2 = SWIG_AsVal_long(obj1, &val2);
41685 if (!SWIG_IsOK(ecode2)) {
41686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41687 }
41688 arg2 = static_cast< long >(val2);
41689 }
41690 {
41691 if (!wxPyCheckForApp()) SWIG_fail;
41692 PyThreadState* __tstate = wxPyBeginAllowThreads();
41693 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41694 wxPyEndAllowThreads(__tstate);
41695 if (PyErr_Occurred()) SWIG_fail;
41696 }
41697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41698 {
41699 if (temp1)
41700 delete arg1;
41701 }
41702 return resultobj;
41703 fail:
41704 {
41705 if (temp1)
41706 delete arg1;
41707 }
41708 return NULL;
41709 }
41710
41711
41712 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41713 PyObject *resultobj = 0;
41714 wxMenu *arg1 = (wxMenu *) 0 ;
41715 int arg2 ;
41716 wxString const &arg3_defvalue = wxPyEmptyString ;
41717 wxString *arg3 = (wxString *) &arg3_defvalue ;
41718 wxString const &arg4_defvalue = wxPyEmptyString ;
41719 wxString *arg4 = (wxString *) &arg4_defvalue ;
41720 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41721 wxMenuItem *result = 0 ;
41722 void *argp1 = 0 ;
41723 int res1 = 0 ;
41724 int val2 ;
41725 int ecode2 = 0 ;
41726 bool temp3 = false ;
41727 bool temp4 = false ;
41728 int val5 ;
41729 int ecode5 = 0 ;
41730 PyObject * obj0 = 0 ;
41731 PyObject * obj1 = 0 ;
41732 PyObject * obj2 = 0 ;
41733 PyObject * obj3 = 0 ;
41734 PyObject * obj4 = 0 ;
41735 char * kwnames[] = {
41736 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41737 };
41738
41739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41741 if (!SWIG_IsOK(res1)) {
41742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41743 }
41744 arg1 = reinterpret_cast< wxMenu * >(argp1);
41745 ecode2 = SWIG_AsVal_int(obj1, &val2);
41746 if (!SWIG_IsOK(ecode2)) {
41747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41748 }
41749 arg2 = static_cast< int >(val2);
41750 if (obj2) {
41751 {
41752 arg3 = wxString_in_helper(obj2);
41753 if (arg3 == NULL) SWIG_fail;
41754 temp3 = true;
41755 }
41756 }
41757 if (obj3) {
41758 {
41759 arg4 = wxString_in_helper(obj3);
41760 if (arg4 == NULL) SWIG_fail;
41761 temp4 = true;
41762 }
41763 }
41764 if (obj4) {
41765 ecode5 = SWIG_AsVal_int(obj4, &val5);
41766 if (!SWIG_IsOK(ecode5)) {
41767 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41768 }
41769 arg5 = static_cast< wxItemKind >(val5);
41770 }
41771 {
41772 PyThreadState* __tstate = wxPyBeginAllowThreads();
41773 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41774 wxPyEndAllowThreads(__tstate);
41775 if (PyErr_Occurred()) SWIG_fail;
41776 }
41777 {
41778 resultobj = wxPyMake_wxObject(result, (bool)0);
41779 }
41780 {
41781 if (temp3)
41782 delete arg3;
41783 }
41784 {
41785 if (temp4)
41786 delete arg4;
41787 }
41788 return resultobj;
41789 fail:
41790 {
41791 if (temp3)
41792 delete arg3;
41793 }
41794 {
41795 if (temp4)
41796 delete arg4;
41797 }
41798 return NULL;
41799 }
41800
41801
41802 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41803 PyObject *resultobj = 0;
41804 wxMenu *arg1 = (wxMenu *) 0 ;
41805 wxMenuItem *result = 0 ;
41806 void *argp1 = 0 ;
41807 int res1 = 0 ;
41808 PyObject *swig_obj[1] ;
41809
41810 if (!args) SWIG_fail;
41811 swig_obj[0] = args;
41812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41813 if (!SWIG_IsOK(res1)) {
41814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41815 }
41816 arg1 = reinterpret_cast< wxMenu * >(argp1);
41817 {
41818 PyThreadState* __tstate = wxPyBeginAllowThreads();
41819 result = (wxMenuItem *)(arg1)->AppendSeparator();
41820 wxPyEndAllowThreads(__tstate);
41821 if (PyErr_Occurred()) SWIG_fail;
41822 }
41823 {
41824 resultobj = wxPyMake_wxObject(result, (bool)0);
41825 }
41826 return resultobj;
41827 fail:
41828 return NULL;
41829 }
41830
41831
41832 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41833 PyObject *resultobj = 0;
41834 wxMenu *arg1 = (wxMenu *) 0 ;
41835 int arg2 ;
41836 wxString *arg3 = 0 ;
41837 wxString const &arg4_defvalue = wxPyEmptyString ;
41838 wxString *arg4 = (wxString *) &arg4_defvalue ;
41839 wxMenuItem *result = 0 ;
41840 void *argp1 = 0 ;
41841 int res1 = 0 ;
41842 int val2 ;
41843 int ecode2 = 0 ;
41844 bool temp3 = false ;
41845 bool temp4 = false ;
41846 PyObject * obj0 = 0 ;
41847 PyObject * obj1 = 0 ;
41848 PyObject * obj2 = 0 ;
41849 PyObject * obj3 = 0 ;
41850 char * kwnames[] = {
41851 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41852 };
41853
41854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41856 if (!SWIG_IsOK(res1)) {
41857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41858 }
41859 arg1 = reinterpret_cast< wxMenu * >(argp1);
41860 ecode2 = SWIG_AsVal_int(obj1, &val2);
41861 if (!SWIG_IsOK(ecode2)) {
41862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41863 }
41864 arg2 = static_cast< int >(val2);
41865 {
41866 arg3 = wxString_in_helper(obj2);
41867 if (arg3 == NULL) SWIG_fail;
41868 temp3 = true;
41869 }
41870 if (obj3) {
41871 {
41872 arg4 = wxString_in_helper(obj3);
41873 if (arg4 == NULL) SWIG_fail;
41874 temp4 = true;
41875 }
41876 }
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = wxPyMake_wxObject(result, (bool)0);
41885 }
41886 {
41887 if (temp3)
41888 delete arg3;
41889 }
41890 {
41891 if (temp4)
41892 delete arg4;
41893 }
41894 return resultobj;
41895 fail:
41896 {
41897 if (temp3)
41898 delete arg3;
41899 }
41900 {
41901 if (temp4)
41902 delete arg4;
41903 }
41904 return NULL;
41905 }
41906
41907
41908 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41909 PyObject *resultobj = 0;
41910 wxMenu *arg1 = (wxMenu *) 0 ;
41911 int arg2 ;
41912 wxString *arg3 = 0 ;
41913 wxString const &arg4_defvalue = wxPyEmptyString ;
41914 wxString *arg4 = (wxString *) &arg4_defvalue ;
41915 wxMenuItem *result = 0 ;
41916 void *argp1 = 0 ;
41917 int res1 = 0 ;
41918 int val2 ;
41919 int ecode2 = 0 ;
41920 bool temp3 = false ;
41921 bool temp4 = false ;
41922 PyObject * obj0 = 0 ;
41923 PyObject * obj1 = 0 ;
41924 PyObject * obj2 = 0 ;
41925 PyObject * obj3 = 0 ;
41926 char * kwnames[] = {
41927 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41928 };
41929
41930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41932 if (!SWIG_IsOK(res1)) {
41933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41934 }
41935 arg1 = reinterpret_cast< wxMenu * >(argp1);
41936 ecode2 = SWIG_AsVal_int(obj1, &val2);
41937 if (!SWIG_IsOK(ecode2)) {
41938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41939 }
41940 arg2 = static_cast< int >(val2);
41941 {
41942 arg3 = wxString_in_helper(obj2);
41943 if (arg3 == NULL) SWIG_fail;
41944 temp3 = true;
41945 }
41946 if (obj3) {
41947 {
41948 arg4 = wxString_in_helper(obj3);
41949 if (arg4 == NULL) SWIG_fail;
41950 temp4 = true;
41951 }
41952 }
41953 {
41954 PyThreadState* __tstate = wxPyBeginAllowThreads();
41955 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41956 wxPyEndAllowThreads(__tstate);
41957 if (PyErr_Occurred()) SWIG_fail;
41958 }
41959 {
41960 resultobj = wxPyMake_wxObject(result, (bool)0);
41961 }
41962 {
41963 if (temp3)
41964 delete arg3;
41965 }
41966 {
41967 if (temp4)
41968 delete arg4;
41969 }
41970 return resultobj;
41971 fail:
41972 {
41973 if (temp3)
41974 delete arg3;
41975 }
41976 {
41977 if (temp4)
41978 delete arg4;
41979 }
41980 return NULL;
41981 }
41982
41983
41984 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41985 PyObject *resultobj = 0;
41986 wxMenu *arg1 = (wxMenu *) 0 ;
41987 int arg2 ;
41988 wxString *arg3 = 0 ;
41989 wxMenu *arg4 = (wxMenu *) 0 ;
41990 wxString const &arg5_defvalue = wxPyEmptyString ;
41991 wxString *arg5 = (wxString *) &arg5_defvalue ;
41992 wxMenuItem *result = 0 ;
41993 void *argp1 = 0 ;
41994 int res1 = 0 ;
41995 int val2 ;
41996 int ecode2 = 0 ;
41997 bool temp3 = false ;
41998 void *argp4 = 0 ;
41999 int res4 = 0 ;
42000 bool temp5 = false ;
42001 PyObject * obj0 = 0 ;
42002 PyObject * obj1 = 0 ;
42003 PyObject * obj2 = 0 ;
42004 PyObject * obj3 = 0 ;
42005 PyObject * obj4 = 0 ;
42006 char * kwnames[] = {
42007 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42008 };
42009
42010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42012 if (!SWIG_IsOK(res1)) {
42013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42014 }
42015 arg1 = reinterpret_cast< wxMenu * >(argp1);
42016 ecode2 = SWIG_AsVal_int(obj1, &val2);
42017 if (!SWIG_IsOK(ecode2)) {
42018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42019 }
42020 arg2 = static_cast< int >(val2);
42021 {
42022 arg3 = wxString_in_helper(obj2);
42023 if (arg3 == NULL) SWIG_fail;
42024 temp3 = true;
42025 }
42026 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42027 if (!SWIG_IsOK(res4)) {
42028 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42029 }
42030 arg4 = reinterpret_cast< wxMenu * >(argp4);
42031 if (obj4) {
42032 {
42033 arg5 = wxString_in_helper(obj4);
42034 if (arg5 == NULL) SWIG_fail;
42035 temp5 = true;
42036 }
42037 }
42038 {
42039 PyThreadState* __tstate = wxPyBeginAllowThreads();
42040 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42041 wxPyEndAllowThreads(__tstate);
42042 if (PyErr_Occurred()) SWIG_fail;
42043 }
42044 {
42045 resultobj = wxPyMake_wxObject(result, (bool)0);
42046 }
42047 {
42048 if (temp3)
42049 delete arg3;
42050 }
42051 {
42052 if (temp5)
42053 delete arg5;
42054 }
42055 return resultobj;
42056 fail:
42057 {
42058 if (temp3)
42059 delete arg3;
42060 }
42061 {
42062 if (temp5)
42063 delete arg5;
42064 }
42065 return NULL;
42066 }
42067
42068
42069 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42070 PyObject *resultobj = 0;
42071 wxMenu *arg1 = (wxMenu *) 0 ;
42072 wxMenu *arg2 = (wxMenu *) 0 ;
42073 wxString *arg3 = 0 ;
42074 wxString const &arg4_defvalue = wxPyEmptyString ;
42075 wxString *arg4 = (wxString *) &arg4_defvalue ;
42076 wxMenuItem *result = 0 ;
42077 void *argp1 = 0 ;
42078 int res1 = 0 ;
42079 void *argp2 = 0 ;
42080 int res2 = 0 ;
42081 bool temp3 = false ;
42082 bool temp4 = false ;
42083 PyObject * obj0 = 0 ;
42084 PyObject * obj1 = 0 ;
42085 PyObject * obj2 = 0 ;
42086 PyObject * obj3 = 0 ;
42087 char * kwnames[] = {
42088 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42089 };
42090
42091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42093 if (!SWIG_IsOK(res1)) {
42094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42095 }
42096 arg1 = reinterpret_cast< wxMenu * >(argp1);
42097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42098 if (!SWIG_IsOK(res2)) {
42099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42100 }
42101 arg2 = reinterpret_cast< wxMenu * >(argp2);
42102 {
42103 arg3 = wxString_in_helper(obj2);
42104 if (arg3 == NULL) SWIG_fail;
42105 temp3 = true;
42106 }
42107 if (obj3) {
42108 {
42109 arg4 = wxString_in_helper(obj3);
42110 if (arg4 == NULL) SWIG_fail;
42111 temp4 = true;
42112 }
42113 }
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 {
42121 resultobj = wxPyMake_wxObject(result, (bool)0);
42122 }
42123 {
42124 if (temp3)
42125 delete arg3;
42126 }
42127 {
42128 if (temp4)
42129 delete arg4;
42130 }
42131 return resultobj;
42132 fail:
42133 {
42134 if (temp3)
42135 delete arg3;
42136 }
42137 {
42138 if (temp4)
42139 delete arg4;
42140 }
42141 return NULL;
42142 }
42143
42144
42145 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42146 PyObject *resultobj = 0;
42147 wxMenu *arg1 = (wxMenu *) 0 ;
42148 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42149 wxMenuItem *result = 0 ;
42150 void *argp1 = 0 ;
42151 int res1 = 0 ;
42152 int res2 = 0 ;
42153 PyObject * obj0 = 0 ;
42154 PyObject * obj1 = 0 ;
42155 char * kwnames[] = {
42156 (char *) "self",(char *) "item", NULL
42157 };
42158
42159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42161 if (!SWIG_IsOK(res1)) {
42162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42163 }
42164 arg1 = reinterpret_cast< wxMenu * >(argp1);
42165 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42166 if (!SWIG_IsOK(res2)) {
42167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42168 }
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 result = (wxMenuItem *)(arg1)->Append(arg2);
42172 wxPyEndAllowThreads(__tstate);
42173 if (PyErr_Occurred()) SWIG_fail;
42174 }
42175 {
42176 resultobj = wxPyMake_wxObject(result, (bool)0);
42177 }
42178 return resultobj;
42179 fail:
42180 return NULL;
42181 }
42182
42183
42184 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42185 PyObject *resultobj = 0;
42186 wxMenu *arg1 = (wxMenu *) 0 ;
42187 size_t arg2 ;
42188 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42189 wxMenuItem *result = 0 ;
42190 void *argp1 = 0 ;
42191 int res1 = 0 ;
42192 size_t val2 ;
42193 int ecode2 = 0 ;
42194 int res3 = 0 ;
42195 PyObject * obj0 = 0 ;
42196 PyObject * obj1 = 0 ;
42197 PyObject * obj2 = 0 ;
42198 char * kwnames[] = {
42199 (char *) "self",(char *) "pos",(char *) "item", NULL
42200 };
42201
42202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42204 if (!SWIG_IsOK(res1)) {
42205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42206 }
42207 arg1 = reinterpret_cast< wxMenu * >(argp1);
42208 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42209 if (!SWIG_IsOK(ecode2)) {
42210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42211 }
42212 arg2 = static_cast< size_t >(val2);
42213 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42214 if (!SWIG_IsOK(res3)) {
42215 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42216 }
42217 {
42218 PyThreadState* __tstate = wxPyBeginAllowThreads();
42219 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42220 wxPyEndAllowThreads(__tstate);
42221 if (PyErr_Occurred()) SWIG_fail;
42222 }
42223 {
42224 resultobj = wxPyMake_wxObject(result, (bool)0);
42225 }
42226 return resultobj;
42227 fail:
42228 return NULL;
42229 }
42230
42231
42232 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42233 PyObject *resultobj = 0;
42234 wxMenu *arg1 = (wxMenu *) 0 ;
42235 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42236 wxMenuItem *result = 0 ;
42237 void *argp1 = 0 ;
42238 int res1 = 0 ;
42239 int res2 = 0 ;
42240 PyObject * obj0 = 0 ;
42241 PyObject * obj1 = 0 ;
42242 char * kwnames[] = {
42243 (char *) "self",(char *) "item", NULL
42244 };
42245
42246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42248 if (!SWIG_IsOK(res1)) {
42249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42250 }
42251 arg1 = reinterpret_cast< wxMenu * >(argp1);
42252 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42253 if (!SWIG_IsOK(res2)) {
42254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42255 }
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42259 wxPyEndAllowThreads(__tstate);
42260 if (PyErr_Occurred()) SWIG_fail;
42261 }
42262 {
42263 resultobj = wxPyMake_wxObject(result, (bool)0);
42264 }
42265 return resultobj;
42266 fail:
42267 return NULL;
42268 }
42269
42270
42271 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42272 PyObject *resultobj = 0;
42273 wxMenu *arg1 = (wxMenu *) 0 ;
42274 void *argp1 = 0 ;
42275 int res1 = 0 ;
42276 PyObject *swig_obj[1] ;
42277
42278 if (!args) SWIG_fail;
42279 swig_obj[0] = args;
42280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42283 }
42284 arg1 = reinterpret_cast< wxMenu * >(argp1);
42285 {
42286 PyThreadState* __tstate = wxPyBeginAllowThreads();
42287 (arg1)->Break();
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 resultobj = SWIG_Py_Void();
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42299 PyObject *resultobj = 0;
42300 wxMenu *arg1 = (wxMenu *) 0 ;
42301 size_t arg2 ;
42302 int arg3 ;
42303 wxString const &arg4_defvalue = wxPyEmptyString ;
42304 wxString *arg4 = (wxString *) &arg4_defvalue ;
42305 wxString const &arg5_defvalue = wxPyEmptyString ;
42306 wxString *arg5 = (wxString *) &arg5_defvalue ;
42307 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42308 wxMenuItem *result = 0 ;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 size_t val2 ;
42312 int ecode2 = 0 ;
42313 int val3 ;
42314 int ecode3 = 0 ;
42315 bool temp4 = false ;
42316 bool temp5 = false ;
42317 int val6 ;
42318 int ecode6 = 0 ;
42319 PyObject * obj0 = 0 ;
42320 PyObject * obj1 = 0 ;
42321 PyObject * obj2 = 0 ;
42322 PyObject * obj3 = 0 ;
42323 PyObject * obj4 = 0 ;
42324 PyObject * obj5 = 0 ;
42325 char * kwnames[] = {
42326 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42327 };
42328
42329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42331 if (!SWIG_IsOK(res1)) {
42332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42333 }
42334 arg1 = reinterpret_cast< wxMenu * >(argp1);
42335 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42336 if (!SWIG_IsOK(ecode2)) {
42337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42338 }
42339 arg2 = static_cast< size_t >(val2);
42340 ecode3 = SWIG_AsVal_int(obj2, &val3);
42341 if (!SWIG_IsOK(ecode3)) {
42342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42343 }
42344 arg3 = static_cast< int >(val3);
42345 if (obj3) {
42346 {
42347 arg4 = wxString_in_helper(obj3);
42348 if (arg4 == NULL) SWIG_fail;
42349 temp4 = true;
42350 }
42351 }
42352 if (obj4) {
42353 {
42354 arg5 = wxString_in_helper(obj4);
42355 if (arg5 == NULL) SWIG_fail;
42356 temp5 = true;
42357 }
42358 }
42359 if (obj5) {
42360 ecode6 = SWIG_AsVal_int(obj5, &val6);
42361 if (!SWIG_IsOK(ecode6)) {
42362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42363 }
42364 arg6 = static_cast< wxItemKind >(val6);
42365 }
42366 {
42367 PyThreadState* __tstate = wxPyBeginAllowThreads();
42368 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42369 wxPyEndAllowThreads(__tstate);
42370 if (PyErr_Occurred()) SWIG_fail;
42371 }
42372 {
42373 resultobj = wxPyMake_wxObject(result, (bool)0);
42374 }
42375 {
42376 if (temp4)
42377 delete arg4;
42378 }
42379 {
42380 if (temp5)
42381 delete arg5;
42382 }
42383 return resultobj;
42384 fail:
42385 {
42386 if (temp4)
42387 delete arg4;
42388 }
42389 {
42390 if (temp5)
42391 delete arg5;
42392 }
42393 return NULL;
42394 }
42395
42396
42397 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj = 0;
42399 wxMenu *arg1 = (wxMenu *) 0 ;
42400 size_t arg2 ;
42401 wxMenuItem *result = 0 ;
42402 void *argp1 = 0 ;
42403 int res1 = 0 ;
42404 size_t val2 ;
42405 int ecode2 = 0 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 char * kwnames[] = {
42409 (char *) "self",(char *) "pos", NULL
42410 };
42411
42412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42414 if (!SWIG_IsOK(res1)) {
42415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42416 }
42417 arg1 = reinterpret_cast< wxMenu * >(argp1);
42418 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42419 if (!SWIG_IsOK(ecode2)) {
42420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42421 }
42422 arg2 = static_cast< size_t >(val2);
42423 {
42424 PyThreadState* __tstate = wxPyBeginAllowThreads();
42425 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42426 wxPyEndAllowThreads(__tstate);
42427 if (PyErr_Occurred()) SWIG_fail;
42428 }
42429 {
42430 resultobj = wxPyMake_wxObject(result, (bool)0);
42431 }
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenu *arg1 = (wxMenu *) 0 ;
42441 size_t arg2 ;
42442 int arg3 ;
42443 wxString *arg4 = 0 ;
42444 wxString const &arg5_defvalue = wxPyEmptyString ;
42445 wxString *arg5 = (wxString *) &arg5_defvalue ;
42446 wxMenuItem *result = 0 ;
42447 void *argp1 = 0 ;
42448 int res1 = 0 ;
42449 size_t val2 ;
42450 int ecode2 = 0 ;
42451 int val3 ;
42452 int ecode3 = 0 ;
42453 bool temp4 = false ;
42454 bool temp5 = false ;
42455 PyObject * obj0 = 0 ;
42456 PyObject * obj1 = 0 ;
42457 PyObject * obj2 = 0 ;
42458 PyObject * obj3 = 0 ;
42459 PyObject * obj4 = 0 ;
42460 char * kwnames[] = {
42461 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42462 };
42463
42464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42466 if (!SWIG_IsOK(res1)) {
42467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42468 }
42469 arg1 = reinterpret_cast< wxMenu * >(argp1);
42470 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42471 if (!SWIG_IsOK(ecode2)) {
42472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42473 }
42474 arg2 = static_cast< size_t >(val2);
42475 ecode3 = SWIG_AsVal_int(obj2, &val3);
42476 if (!SWIG_IsOK(ecode3)) {
42477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42478 }
42479 arg3 = static_cast< int >(val3);
42480 {
42481 arg4 = wxString_in_helper(obj3);
42482 if (arg4 == NULL) SWIG_fail;
42483 temp4 = true;
42484 }
42485 if (obj4) {
42486 {
42487 arg5 = wxString_in_helper(obj4);
42488 if (arg5 == NULL) SWIG_fail;
42489 temp5 = true;
42490 }
42491 }
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42495 wxPyEndAllowThreads(__tstate);
42496 if (PyErr_Occurred()) SWIG_fail;
42497 }
42498 {
42499 resultobj = wxPyMake_wxObject(result, (bool)0);
42500 }
42501 {
42502 if (temp4)
42503 delete arg4;
42504 }
42505 {
42506 if (temp5)
42507 delete arg5;
42508 }
42509 return resultobj;
42510 fail:
42511 {
42512 if (temp4)
42513 delete arg4;
42514 }
42515 {
42516 if (temp5)
42517 delete arg5;
42518 }
42519 return NULL;
42520 }
42521
42522
42523 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42524 PyObject *resultobj = 0;
42525 wxMenu *arg1 = (wxMenu *) 0 ;
42526 size_t arg2 ;
42527 int arg3 ;
42528 wxString *arg4 = 0 ;
42529 wxString const &arg5_defvalue = wxPyEmptyString ;
42530 wxString *arg5 = (wxString *) &arg5_defvalue ;
42531 wxMenuItem *result = 0 ;
42532 void *argp1 = 0 ;
42533 int res1 = 0 ;
42534 size_t val2 ;
42535 int ecode2 = 0 ;
42536 int val3 ;
42537 int ecode3 = 0 ;
42538 bool temp4 = false ;
42539 bool temp5 = false ;
42540 PyObject * obj0 = 0 ;
42541 PyObject * obj1 = 0 ;
42542 PyObject * obj2 = 0 ;
42543 PyObject * obj3 = 0 ;
42544 PyObject * obj4 = 0 ;
42545 char * kwnames[] = {
42546 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42547 };
42548
42549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42551 if (!SWIG_IsOK(res1)) {
42552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42553 }
42554 arg1 = reinterpret_cast< wxMenu * >(argp1);
42555 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42556 if (!SWIG_IsOK(ecode2)) {
42557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42558 }
42559 arg2 = static_cast< size_t >(val2);
42560 ecode3 = SWIG_AsVal_int(obj2, &val3);
42561 if (!SWIG_IsOK(ecode3)) {
42562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42563 }
42564 arg3 = static_cast< int >(val3);
42565 {
42566 arg4 = wxString_in_helper(obj3);
42567 if (arg4 == NULL) SWIG_fail;
42568 temp4 = true;
42569 }
42570 if (obj4) {
42571 {
42572 arg5 = wxString_in_helper(obj4);
42573 if (arg5 == NULL) SWIG_fail;
42574 temp5 = true;
42575 }
42576 }
42577 {
42578 PyThreadState* __tstate = wxPyBeginAllowThreads();
42579 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42580 wxPyEndAllowThreads(__tstate);
42581 if (PyErr_Occurred()) SWIG_fail;
42582 }
42583 {
42584 resultobj = wxPyMake_wxObject(result, (bool)0);
42585 }
42586 {
42587 if (temp4)
42588 delete arg4;
42589 }
42590 {
42591 if (temp5)
42592 delete arg5;
42593 }
42594 return resultobj;
42595 fail:
42596 {
42597 if (temp4)
42598 delete arg4;
42599 }
42600 {
42601 if (temp5)
42602 delete arg5;
42603 }
42604 return NULL;
42605 }
42606
42607
42608 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42609 PyObject *resultobj = 0;
42610 wxMenu *arg1 = (wxMenu *) 0 ;
42611 size_t arg2 ;
42612 int arg3 ;
42613 wxString *arg4 = 0 ;
42614 wxMenu *arg5 = (wxMenu *) 0 ;
42615 wxString const &arg6_defvalue = wxPyEmptyString ;
42616 wxString *arg6 = (wxString *) &arg6_defvalue ;
42617 wxMenuItem *result = 0 ;
42618 void *argp1 = 0 ;
42619 int res1 = 0 ;
42620 size_t val2 ;
42621 int ecode2 = 0 ;
42622 int val3 ;
42623 int ecode3 = 0 ;
42624 bool temp4 = false ;
42625 void *argp5 = 0 ;
42626 int res5 = 0 ;
42627 bool temp6 = false ;
42628 PyObject * obj0 = 0 ;
42629 PyObject * obj1 = 0 ;
42630 PyObject * obj2 = 0 ;
42631 PyObject * obj3 = 0 ;
42632 PyObject * obj4 = 0 ;
42633 PyObject * obj5 = 0 ;
42634 char * kwnames[] = {
42635 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42636 };
42637
42638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenu * >(argp1);
42644 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42645 if (!SWIG_IsOK(ecode2)) {
42646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42647 }
42648 arg2 = static_cast< size_t >(val2);
42649 ecode3 = SWIG_AsVal_int(obj2, &val3);
42650 if (!SWIG_IsOK(ecode3)) {
42651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42652 }
42653 arg3 = static_cast< int >(val3);
42654 {
42655 arg4 = wxString_in_helper(obj3);
42656 if (arg4 == NULL) SWIG_fail;
42657 temp4 = true;
42658 }
42659 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42660 if (!SWIG_IsOK(res5)) {
42661 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42662 }
42663 arg5 = reinterpret_cast< wxMenu * >(argp5);
42664 if (obj5) {
42665 {
42666 arg6 = wxString_in_helper(obj5);
42667 if (arg6 == NULL) SWIG_fail;
42668 temp6 = true;
42669 }
42670 }
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42674 wxPyEndAllowThreads(__tstate);
42675 if (PyErr_Occurred()) SWIG_fail;
42676 }
42677 {
42678 resultobj = wxPyMake_wxObject(result, (bool)0);
42679 }
42680 {
42681 if (temp4)
42682 delete arg4;
42683 }
42684 {
42685 if (temp6)
42686 delete arg6;
42687 }
42688 return resultobj;
42689 fail:
42690 {
42691 if (temp4)
42692 delete arg4;
42693 }
42694 {
42695 if (temp6)
42696 delete arg6;
42697 }
42698 return NULL;
42699 }
42700
42701
42702 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42703 PyObject *resultobj = 0;
42704 wxMenu *arg1 = (wxMenu *) 0 ;
42705 int arg2 ;
42706 wxString const &arg3_defvalue = wxPyEmptyString ;
42707 wxString *arg3 = (wxString *) &arg3_defvalue ;
42708 wxString const &arg4_defvalue = wxPyEmptyString ;
42709 wxString *arg4 = (wxString *) &arg4_defvalue ;
42710 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42711 wxMenuItem *result = 0 ;
42712 void *argp1 = 0 ;
42713 int res1 = 0 ;
42714 int val2 ;
42715 int ecode2 = 0 ;
42716 bool temp3 = false ;
42717 bool temp4 = false ;
42718 int val5 ;
42719 int ecode5 = 0 ;
42720 PyObject * obj0 = 0 ;
42721 PyObject * obj1 = 0 ;
42722 PyObject * obj2 = 0 ;
42723 PyObject * obj3 = 0 ;
42724 PyObject * obj4 = 0 ;
42725 char * kwnames[] = {
42726 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42727 };
42728
42729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42731 if (!SWIG_IsOK(res1)) {
42732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42733 }
42734 arg1 = reinterpret_cast< wxMenu * >(argp1);
42735 ecode2 = SWIG_AsVal_int(obj1, &val2);
42736 if (!SWIG_IsOK(ecode2)) {
42737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42738 }
42739 arg2 = static_cast< int >(val2);
42740 if (obj2) {
42741 {
42742 arg3 = wxString_in_helper(obj2);
42743 if (arg3 == NULL) SWIG_fail;
42744 temp3 = true;
42745 }
42746 }
42747 if (obj3) {
42748 {
42749 arg4 = wxString_in_helper(obj3);
42750 if (arg4 == NULL) SWIG_fail;
42751 temp4 = true;
42752 }
42753 }
42754 if (obj4) {
42755 ecode5 = SWIG_AsVal_int(obj4, &val5);
42756 if (!SWIG_IsOK(ecode5)) {
42757 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42758 }
42759 arg5 = static_cast< wxItemKind >(val5);
42760 }
42761 {
42762 PyThreadState* __tstate = wxPyBeginAllowThreads();
42763 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42764 wxPyEndAllowThreads(__tstate);
42765 if (PyErr_Occurred()) SWIG_fail;
42766 }
42767 {
42768 resultobj = wxPyMake_wxObject(result, (bool)0);
42769 }
42770 {
42771 if (temp3)
42772 delete arg3;
42773 }
42774 {
42775 if (temp4)
42776 delete arg4;
42777 }
42778 return resultobj;
42779 fail:
42780 {
42781 if (temp3)
42782 delete arg3;
42783 }
42784 {
42785 if (temp4)
42786 delete arg4;
42787 }
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42793 PyObject *resultobj = 0;
42794 wxMenu *arg1 = (wxMenu *) 0 ;
42795 wxMenuItem *result = 0 ;
42796 void *argp1 = 0 ;
42797 int res1 = 0 ;
42798 PyObject *swig_obj[1] ;
42799
42800 if (!args) SWIG_fail;
42801 swig_obj[0] = args;
42802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42803 if (!SWIG_IsOK(res1)) {
42804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42805 }
42806 arg1 = reinterpret_cast< wxMenu * >(argp1);
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (wxMenuItem *)(arg1)->PrependSeparator();
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 {
42814 resultobj = wxPyMake_wxObject(result, (bool)0);
42815 }
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj = 0;
42824 wxMenu *arg1 = (wxMenu *) 0 ;
42825 int arg2 ;
42826 wxString *arg3 = 0 ;
42827 wxString const &arg4_defvalue = wxPyEmptyString ;
42828 wxString *arg4 = (wxString *) &arg4_defvalue ;
42829 wxMenuItem *result = 0 ;
42830 void *argp1 = 0 ;
42831 int res1 = 0 ;
42832 int val2 ;
42833 int ecode2 = 0 ;
42834 bool temp3 = false ;
42835 bool temp4 = false ;
42836 PyObject * obj0 = 0 ;
42837 PyObject * obj1 = 0 ;
42838 PyObject * obj2 = 0 ;
42839 PyObject * obj3 = 0 ;
42840 char * kwnames[] = {
42841 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42842 };
42843
42844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42846 if (!SWIG_IsOK(res1)) {
42847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42848 }
42849 arg1 = reinterpret_cast< wxMenu * >(argp1);
42850 ecode2 = SWIG_AsVal_int(obj1, &val2);
42851 if (!SWIG_IsOK(ecode2)) {
42852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42853 }
42854 arg2 = static_cast< int >(val2);
42855 {
42856 arg3 = wxString_in_helper(obj2);
42857 if (arg3 == NULL) SWIG_fail;
42858 temp3 = true;
42859 }
42860 if (obj3) {
42861 {
42862 arg4 = wxString_in_helper(obj3);
42863 if (arg4 == NULL) SWIG_fail;
42864 temp4 = true;
42865 }
42866 }
42867 {
42868 PyThreadState* __tstate = wxPyBeginAllowThreads();
42869 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 {
42874 resultobj = wxPyMake_wxObject(result, (bool)0);
42875 }
42876 {
42877 if (temp3)
42878 delete arg3;
42879 }
42880 {
42881 if (temp4)
42882 delete arg4;
42883 }
42884 return resultobj;
42885 fail:
42886 {
42887 if (temp3)
42888 delete arg3;
42889 }
42890 {
42891 if (temp4)
42892 delete arg4;
42893 }
42894 return NULL;
42895 }
42896
42897
42898 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42899 PyObject *resultobj = 0;
42900 wxMenu *arg1 = (wxMenu *) 0 ;
42901 int arg2 ;
42902 wxString *arg3 = 0 ;
42903 wxString const &arg4_defvalue = wxPyEmptyString ;
42904 wxString *arg4 = (wxString *) &arg4_defvalue ;
42905 wxMenuItem *result = 0 ;
42906 void *argp1 = 0 ;
42907 int res1 = 0 ;
42908 int val2 ;
42909 int ecode2 = 0 ;
42910 bool temp3 = false ;
42911 bool temp4 = false ;
42912 PyObject * obj0 = 0 ;
42913 PyObject * obj1 = 0 ;
42914 PyObject * obj2 = 0 ;
42915 PyObject * obj3 = 0 ;
42916 char * kwnames[] = {
42917 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42918 };
42919
42920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42922 if (!SWIG_IsOK(res1)) {
42923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42924 }
42925 arg1 = reinterpret_cast< wxMenu * >(argp1);
42926 ecode2 = SWIG_AsVal_int(obj1, &val2);
42927 if (!SWIG_IsOK(ecode2)) {
42928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42929 }
42930 arg2 = static_cast< int >(val2);
42931 {
42932 arg3 = wxString_in_helper(obj2);
42933 if (arg3 == NULL) SWIG_fail;
42934 temp3 = true;
42935 }
42936 if (obj3) {
42937 {
42938 arg4 = wxString_in_helper(obj3);
42939 if (arg4 == NULL) SWIG_fail;
42940 temp4 = true;
42941 }
42942 }
42943 {
42944 PyThreadState* __tstate = wxPyBeginAllowThreads();
42945 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 {
42950 resultobj = wxPyMake_wxObject(result, (bool)0);
42951 }
42952 {
42953 if (temp3)
42954 delete arg3;
42955 }
42956 {
42957 if (temp4)
42958 delete arg4;
42959 }
42960 return resultobj;
42961 fail:
42962 {
42963 if (temp3)
42964 delete arg3;
42965 }
42966 {
42967 if (temp4)
42968 delete arg4;
42969 }
42970 return NULL;
42971 }
42972
42973
42974 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = 0;
42976 wxMenu *arg1 = (wxMenu *) 0 ;
42977 int arg2 ;
42978 wxString *arg3 = 0 ;
42979 wxMenu *arg4 = (wxMenu *) 0 ;
42980 wxString const &arg5_defvalue = wxPyEmptyString ;
42981 wxString *arg5 = (wxString *) &arg5_defvalue ;
42982 wxMenuItem *result = 0 ;
42983 void *argp1 = 0 ;
42984 int res1 = 0 ;
42985 int val2 ;
42986 int ecode2 = 0 ;
42987 bool temp3 = false ;
42988 void *argp4 = 0 ;
42989 int res4 = 0 ;
42990 bool temp5 = false ;
42991 PyObject * obj0 = 0 ;
42992 PyObject * obj1 = 0 ;
42993 PyObject * obj2 = 0 ;
42994 PyObject * obj3 = 0 ;
42995 PyObject * obj4 = 0 ;
42996 char * kwnames[] = {
42997 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42998 };
42999
43000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43002 if (!SWIG_IsOK(res1)) {
43003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43004 }
43005 arg1 = reinterpret_cast< wxMenu * >(argp1);
43006 ecode2 = SWIG_AsVal_int(obj1, &val2);
43007 if (!SWIG_IsOK(ecode2)) {
43008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43009 }
43010 arg2 = static_cast< int >(val2);
43011 {
43012 arg3 = wxString_in_helper(obj2);
43013 if (arg3 == NULL) SWIG_fail;
43014 temp3 = true;
43015 }
43016 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43017 if (!SWIG_IsOK(res4)) {
43018 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43019 }
43020 arg4 = reinterpret_cast< wxMenu * >(argp4);
43021 if (obj4) {
43022 {
43023 arg5 = wxString_in_helper(obj4);
43024 if (arg5 == NULL) SWIG_fail;
43025 temp5 = true;
43026 }
43027 }
43028 {
43029 PyThreadState* __tstate = wxPyBeginAllowThreads();
43030 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43031 wxPyEndAllowThreads(__tstate);
43032 if (PyErr_Occurred()) SWIG_fail;
43033 }
43034 {
43035 resultobj = wxPyMake_wxObject(result, (bool)0);
43036 }
43037 {
43038 if (temp3)
43039 delete arg3;
43040 }
43041 {
43042 if (temp5)
43043 delete arg5;
43044 }
43045 return resultobj;
43046 fail:
43047 {
43048 if (temp3)
43049 delete arg3;
43050 }
43051 {
43052 if (temp5)
43053 delete arg5;
43054 }
43055 return NULL;
43056 }
43057
43058
43059 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43060 PyObject *resultobj = 0;
43061 wxMenu *arg1 = (wxMenu *) 0 ;
43062 int arg2 ;
43063 wxMenuItem *result = 0 ;
43064 void *argp1 = 0 ;
43065 int res1 = 0 ;
43066 int val2 ;
43067 int ecode2 = 0 ;
43068 PyObject * obj0 = 0 ;
43069 PyObject * obj1 = 0 ;
43070 char * kwnames[] = {
43071 (char *) "self",(char *) "id", NULL
43072 };
43073
43074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43076 if (!SWIG_IsOK(res1)) {
43077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43078 }
43079 arg1 = reinterpret_cast< wxMenu * >(argp1);
43080 ecode2 = SWIG_AsVal_int(obj1, &val2);
43081 if (!SWIG_IsOK(ecode2)) {
43082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43083 }
43084 arg2 = static_cast< int >(val2);
43085 {
43086 PyThreadState* __tstate = wxPyBeginAllowThreads();
43087 result = (wxMenuItem *)(arg1)->Remove(arg2);
43088 wxPyEndAllowThreads(__tstate);
43089 if (PyErr_Occurred()) SWIG_fail;
43090 }
43091 {
43092 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43093 }
43094 return resultobj;
43095 fail:
43096 return NULL;
43097 }
43098
43099
43100 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43101 PyObject *resultobj = 0;
43102 wxMenu *arg1 = (wxMenu *) 0 ;
43103 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43104 wxMenuItem *result = 0 ;
43105 void *argp1 = 0 ;
43106 int res1 = 0 ;
43107 void *argp2 = 0 ;
43108 int res2 = 0 ;
43109 PyObject * obj0 = 0 ;
43110 PyObject * obj1 = 0 ;
43111 char * kwnames[] = {
43112 (char *) "self",(char *) "item", NULL
43113 };
43114
43115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43117 if (!SWIG_IsOK(res1)) {
43118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43119 }
43120 arg1 = reinterpret_cast< wxMenu * >(argp1);
43121 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43122 if (!SWIG_IsOK(res2)) {
43123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43124 }
43125 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43126 {
43127 PyThreadState* __tstate = wxPyBeginAllowThreads();
43128 result = (wxMenuItem *)(arg1)->Remove(arg2);
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43134 }
43135 return resultobj;
43136 fail:
43137 return NULL;
43138 }
43139
43140
43141 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43142 PyObject *resultobj = 0;
43143 wxMenu *arg1 = (wxMenu *) 0 ;
43144 int arg2 ;
43145 bool result;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 int val2 ;
43149 int ecode2 = 0 ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 char * kwnames[] = {
43153 (char *) "self",(char *) "id", NULL
43154 };
43155
43156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43158 if (!SWIG_IsOK(res1)) {
43159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43160 }
43161 arg1 = reinterpret_cast< wxMenu * >(argp1);
43162 ecode2 = SWIG_AsVal_int(obj1, &val2);
43163 if (!SWIG_IsOK(ecode2)) {
43164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43165 }
43166 arg2 = static_cast< int >(val2);
43167 {
43168 PyThreadState* __tstate = wxPyBeginAllowThreads();
43169 result = (bool)(arg1)->Delete(arg2);
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 {
43174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43175 }
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenu *arg1 = (wxMenu *) 0 ;
43185 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43186 bool result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 void *argp2 = 0 ;
43190 int res2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "item", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenu * >(argp1);
43203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43204 if (!SWIG_IsOK(res2)) {
43205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43206 }
43207 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (bool)(arg1)->Delete(arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 {
43215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43216 }
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43224 PyObject *resultobj = 0;
43225 wxMenu *arg1 = (wxMenu *) 0 ;
43226 void *argp1 = 0 ;
43227 int res1 = 0 ;
43228 PyObject *swig_obj[1] ;
43229
43230 if (!args) SWIG_fail;
43231 swig_obj[0] = args;
43232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43233 if (!SWIG_IsOK(res1)) {
43234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43235 }
43236 arg1 = reinterpret_cast< wxMenu * >(argp1);
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 wxMenu_Destroy(arg1);
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 resultobj = SWIG_Py_Void();
43244 return resultobj;
43245 fail:
43246 return NULL;
43247 }
43248
43249
43250 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43251 PyObject *resultobj = 0;
43252 wxMenu *arg1 = (wxMenu *) 0 ;
43253 int arg2 ;
43254 bool result;
43255 void *argp1 = 0 ;
43256 int res1 = 0 ;
43257 int val2 ;
43258 int ecode2 = 0 ;
43259 PyObject * obj0 = 0 ;
43260 PyObject * obj1 = 0 ;
43261 char * kwnames[] = {
43262 (char *) "self",(char *) "id", NULL
43263 };
43264
43265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43267 if (!SWIG_IsOK(res1)) {
43268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43269 }
43270 arg1 = reinterpret_cast< wxMenu * >(argp1);
43271 ecode2 = SWIG_AsVal_int(obj1, &val2);
43272 if (!SWIG_IsOK(ecode2)) {
43273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43274 }
43275 arg2 = static_cast< int >(val2);
43276 {
43277 PyThreadState* __tstate = wxPyBeginAllowThreads();
43278 result = (bool)(arg1)->Destroy(arg2);
43279 wxPyEndAllowThreads(__tstate);
43280 if (PyErr_Occurred()) SWIG_fail;
43281 }
43282 {
43283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43284 }
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43292 PyObject *resultobj = 0;
43293 wxMenu *arg1 = (wxMenu *) 0 ;
43294 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43295 bool result;
43296 void *argp1 = 0 ;
43297 int res1 = 0 ;
43298 void *argp2 = 0 ;
43299 int res2 = 0 ;
43300 PyObject * obj0 = 0 ;
43301 PyObject * obj1 = 0 ;
43302 char * kwnames[] = {
43303 (char *) "self",(char *) "item", NULL
43304 };
43305
43306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43308 if (!SWIG_IsOK(res1)) {
43309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43310 }
43311 arg1 = reinterpret_cast< wxMenu * >(argp1);
43312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43313 if (!SWIG_IsOK(res2)) {
43314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43315 }
43316 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43317 {
43318 PyThreadState* __tstate = wxPyBeginAllowThreads();
43319 result = (bool)(arg1)->Destroy(arg2);
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 {
43324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43325 }
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43333 PyObject *resultobj = 0;
43334 wxMenu *arg1 = (wxMenu *) 0 ;
43335 size_t result;
43336 void *argp1 = 0 ;
43337 int res1 = 0 ;
43338 PyObject *swig_obj[1] ;
43339
43340 if (!args) SWIG_fail;
43341 swig_obj[0] = args;
43342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43343 if (!SWIG_IsOK(res1)) {
43344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43345 }
43346 arg1 = reinterpret_cast< wxMenu * >(argp1);
43347 {
43348 PyThreadState* __tstate = wxPyBeginAllowThreads();
43349 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43350 wxPyEndAllowThreads(__tstate);
43351 if (PyErr_Occurred()) SWIG_fail;
43352 }
43353 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43354 return resultobj;
43355 fail:
43356 return NULL;
43357 }
43358
43359
43360 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43361 PyObject *resultobj = 0;
43362 wxMenu *arg1 = (wxMenu *) 0 ;
43363 PyObject *result = 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 PyObject *swig_obj[1] ;
43367
43368 if (!args) SWIG_fail;
43369 swig_obj[0] = args;
43370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43371 if (!SWIG_IsOK(res1)) {
43372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43373 }
43374 arg1 = reinterpret_cast< wxMenu * >(argp1);
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 resultobj = result;
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43389 PyObject *resultobj = 0;
43390 wxMenu *arg1 = (wxMenu *) 0 ;
43391 wxString *arg2 = 0 ;
43392 int result;
43393 void *argp1 = 0 ;
43394 int res1 = 0 ;
43395 bool temp2 = false ;
43396 PyObject * obj0 = 0 ;
43397 PyObject * obj1 = 0 ;
43398 char * kwnames[] = {
43399 (char *) "self",(char *) "item", NULL
43400 };
43401
43402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43404 if (!SWIG_IsOK(res1)) {
43405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43406 }
43407 arg1 = reinterpret_cast< wxMenu * >(argp1);
43408 {
43409 arg2 = wxString_in_helper(obj1);
43410 if (arg2 == NULL) SWIG_fail;
43411 temp2 = true;
43412 }
43413 {
43414 PyThreadState* __tstate = wxPyBeginAllowThreads();
43415 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 resultobj = SWIG_From_int(static_cast< int >(result));
43420 {
43421 if (temp2)
43422 delete arg2;
43423 }
43424 return resultobj;
43425 fail:
43426 {
43427 if (temp2)
43428 delete arg2;
43429 }
43430 return NULL;
43431 }
43432
43433
43434 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj = 0;
43436 wxMenu *arg1 = (wxMenu *) 0 ;
43437 int arg2 ;
43438 wxMenuItem *result = 0 ;
43439 void *argp1 = 0 ;
43440 int res1 = 0 ;
43441 int val2 ;
43442 int ecode2 = 0 ;
43443 PyObject * obj0 = 0 ;
43444 PyObject * obj1 = 0 ;
43445 char * kwnames[] = {
43446 (char *) "self",(char *) "id", NULL
43447 };
43448
43449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43451 if (!SWIG_IsOK(res1)) {
43452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43453 }
43454 arg1 = reinterpret_cast< wxMenu * >(argp1);
43455 ecode2 = SWIG_AsVal_int(obj1, &val2);
43456 if (!SWIG_IsOK(ecode2)) {
43457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43458 }
43459 arg2 = static_cast< int >(val2);
43460 {
43461 PyThreadState* __tstate = wxPyBeginAllowThreads();
43462 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43463 wxPyEndAllowThreads(__tstate);
43464 if (PyErr_Occurred()) SWIG_fail;
43465 }
43466 {
43467 resultobj = wxPyMake_wxObject(result, (bool)0);
43468 }
43469 return resultobj;
43470 fail:
43471 return NULL;
43472 }
43473
43474
43475 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43476 PyObject *resultobj = 0;
43477 wxMenu *arg1 = (wxMenu *) 0 ;
43478 size_t arg2 ;
43479 wxMenuItem *result = 0 ;
43480 void *argp1 = 0 ;
43481 int res1 = 0 ;
43482 size_t val2 ;
43483 int ecode2 = 0 ;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486 char * kwnames[] = {
43487 (char *) "self",(char *) "position", NULL
43488 };
43489
43490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43492 if (!SWIG_IsOK(res1)) {
43493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43494 }
43495 arg1 = reinterpret_cast< wxMenu * >(argp1);
43496 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43497 if (!SWIG_IsOK(ecode2)) {
43498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43499 }
43500 arg2 = static_cast< size_t >(val2);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 resultobj = wxPyMake_wxObject(result, (bool)0);
43509 }
43510 return resultobj;
43511 fail:
43512 return NULL;
43513 }
43514
43515
43516 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43517 PyObject *resultobj = 0;
43518 wxMenu *arg1 = (wxMenu *) 0 ;
43519 int arg2 ;
43520 bool arg3 ;
43521 void *argp1 = 0 ;
43522 int res1 = 0 ;
43523 int val2 ;
43524 int ecode2 = 0 ;
43525 bool val3 ;
43526 int ecode3 = 0 ;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529 PyObject * obj2 = 0 ;
43530 char * kwnames[] = {
43531 (char *) "self",(char *) "id",(char *) "enable", NULL
43532 };
43533
43534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43536 if (!SWIG_IsOK(res1)) {
43537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43538 }
43539 arg1 = reinterpret_cast< wxMenu * >(argp1);
43540 ecode2 = SWIG_AsVal_int(obj1, &val2);
43541 if (!SWIG_IsOK(ecode2)) {
43542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43543 }
43544 arg2 = static_cast< int >(val2);
43545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43546 if (!SWIG_IsOK(ecode3)) {
43547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43548 }
43549 arg3 = static_cast< bool >(val3);
43550 {
43551 PyThreadState* __tstate = wxPyBeginAllowThreads();
43552 (arg1)->Enable(arg2,arg3);
43553 wxPyEndAllowThreads(__tstate);
43554 if (PyErr_Occurred()) SWIG_fail;
43555 }
43556 resultobj = SWIG_Py_Void();
43557 return resultobj;
43558 fail:
43559 return NULL;
43560 }
43561
43562
43563 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43564 PyObject *resultobj = 0;
43565 wxMenu *arg1 = (wxMenu *) 0 ;
43566 int arg2 ;
43567 bool result;
43568 void *argp1 = 0 ;
43569 int res1 = 0 ;
43570 int val2 ;
43571 int ecode2 = 0 ;
43572 PyObject * obj0 = 0 ;
43573 PyObject * obj1 = 0 ;
43574 char * kwnames[] = {
43575 (char *) "self",(char *) "id", NULL
43576 };
43577
43578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43580 if (!SWIG_IsOK(res1)) {
43581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43582 }
43583 arg1 = reinterpret_cast< wxMenu * >(argp1);
43584 ecode2 = SWIG_AsVal_int(obj1, &val2);
43585 if (!SWIG_IsOK(ecode2)) {
43586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43587 }
43588 arg2 = static_cast< int >(val2);
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43592 wxPyEndAllowThreads(__tstate);
43593 if (PyErr_Occurred()) SWIG_fail;
43594 }
43595 {
43596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43597 }
43598 return resultobj;
43599 fail:
43600 return NULL;
43601 }
43602
43603
43604 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43605 PyObject *resultobj = 0;
43606 wxMenu *arg1 = (wxMenu *) 0 ;
43607 int arg2 ;
43608 bool arg3 ;
43609 void *argp1 = 0 ;
43610 int res1 = 0 ;
43611 int val2 ;
43612 int ecode2 = 0 ;
43613 bool val3 ;
43614 int ecode3 = 0 ;
43615 PyObject * obj0 = 0 ;
43616 PyObject * obj1 = 0 ;
43617 PyObject * obj2 = 0 ;
43618 char * kwnames[] = {
43619 (char *) "self",(char *) "id",(char *) "check", NULL
43620 };
43621
43622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43624 if (!SWIG_IsOK(res1)) {
43625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43626 }
43627 arg1 = reinterpret_cast< wxMenu * >(argp1);
43628 ecode2 = SWIG_AsVal_int(obj1, &val2);
43629 if (!SWIG_IsOK(ecode2)) {
43630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43631 }
43632 arg2 = static_cast< int >(val2);
43633 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43634 if (!SWIG_IsOK(ecode3)) {
43635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43636 }
43637 arg3 = static_cast< bool >(val3);
43638 {
43639 PyThreadState* __tstate = wxPyBeginAllowThreads();
43640 (arg1)->Check(arg2,arg3);
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 resultobj = SWIG_Py_Void();
43645 return resultobj;
43646 fail:
43647 return NULL;
43648 }
43649
43650
43651 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43652 PyObject *resultobj = 0;
43653 wxMenu *arg1 = (wxMenu *) 0 ;
43654 int arg2 ;
43655 bool result;
43656 void *argp1 = 0 ;
43657 int res1 = 0 ;
43658 int val2 ;
43659 int ecode2 = 0 ;
43660 PyObject * obj0 = 0 ;
43661 PyObject * obj1 = 0 ;
43662 char * kwnames[] = {
43663 (char *) "self",(char *) "id", NULL
43664 };
43665
43666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43668 if (!SWIG_IsOK(res1)) {
43669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43670 }
43671 arg1 = reinterpret_cast< wxMenu * >(argp1);
43672 ecode2 = SWIG_AsVal_int(obj1, &val2);
43673 if (!SWIG_IsOK(ecode2)) {
43674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43675 }
43676 arg2 = static_cast< int >(val2);
43677 {
43678 PyThreadState* __tstate = wxPyBeginAllowThreads();
43679 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43680 wxPyEndAllowThreads(__tstate);
43681 if (PyErr_Occurred()) SWIG_fail;
43682 }
43683 {
43684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43685 }
43686 return resultobj;
43687 fail:
43688 return NULL;
43689 }
43690
43691
43692 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43693 PyObject *resultobj = 0;
43694 wxMenu *arg1 = (wxMenu *) 0 ;
43695 int arg2 ;
43696 wxString *arg3 = 0 ;
43697 void *argp1 = 0 ;
43698 int res1 = 0 ;
43699 int val2 ;
43700 int ecode2 = 0 ;
43701 bool temp3 = false ;
43702 PyObject * obj0 = 0 ;
43703 PyObject * obj1 = 0 ;
43704 PyObject * obj2 = 0 ;
43705 char * kwnames[] = {
43706 (char *) "self",(char *) "id",(char *) "label", NULL
43707 };
43708
43709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43711 if (!SWIG_IsOK(res1)) {
43712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43713 }
43714 arg1 = reinterpret_cast< wxMenu * >(argp1);
43715 ecode2 = SWIG_AsVal_int(obj1, &val2);
43716 if (!SWIG_IsOK(ecode2)) {
43717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43718 }
43719 arg2 = static_cast< int >(val2);
43720 {
43721 arg3 = wxString_in_helper(obj2);
43722 if (arg3 == NULL) SWIG_fail;
43723 temp3 = true;
43724 }
43725 {
43726 PyThreadState* __tstate = wxPyBeginAllowThreads();
43727 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43728 wxPyEndAllowThreads(__tstate);
43729 if (PyErr_Occurred()) SWIG_fail;
43730 }
43731 resultobj = SWIG_Py_Void();
43732 {
43733 if (temp3)
43734 delete arg3;
43735 }
43736 return resultobj;
43737 fail:
43738 {
43739 if (temp3)
43740 delete arg3;
43741 }
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43747 PyObject *resultobj = 0;
43748 wxMenu *arg1 = (wxMenu *) 0 ;
43749 int arg2 ;
43750 wxString result;
43751 void *argp1 = 0 ;
43752 int res1 = 0 ;
43753 int val2 ;
43754 int ecode2 = 0 ;
43755 PyObject * obj0 = 0 ;
43756 PyObject * obj1 = 0 ;
43757 char * kwnames[] = {
43758 (char *) "self",(char *) "id", NULL
43759 };
43760
43761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43763 if (!SWIG_IsOK(res1)) {
43764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43765 }
43766 arg1 = reinterpret_cast< wxMenu * >(argp1);
43767 ecode2 = SWIG_AsVal_int(obj1, &val2);
43768 if (!SWIG_IsOK(ecode2)) {
43769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43770 }
43771 arg2 = static_cast< int >(val2);
43772 {
43773 PyThreadState* __tstate = wxPyBeginAllowThreads();
43774 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 {
43779 #if wxUSE_UNICODE
43780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43781 #else
43782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43783 #endif
43784 }
43785 return resultobj;
43786 fail:
43787 return NULL;
43788 }
43789
43790
43791 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = 0;
43793 wxMenu *arg1 = (wxMenu *) 0 ;
43794 int arg2 ;
43795 wxString *arg3 = 0 ;
43796 void *argp1 = 0 ;
43797 int res1 = 0 ;
43798 int val2 ;
43799 int ecode2 = 0 ;
43800 bool temp3 = false ;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803 PyObject * obj2 = 0 ;
43804 char * kwnames[] = {
43805 (char *) "self",(char *) "id",(char *) "helpString", NULL
43806 };
43807
43808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43810 if (!SWIG_IsOK(res1)) {
43811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43812 }
43813 arg1 = reinterpret_cast< wxMenu * >(argp1);
43814 ecode2 = SWIG_AsVal_int(obj1, &val2);
43815 if (!SWIG_IsOK(ecode2)) {
43816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43817 }
43818 arg2 = static_cast< int >(val2);
43819 {
43820 arg3 = wxString_in_helper(obj2);
43821 if (arg3 == NULL) SWIG_fail;
43822 temp3 = true;
43823 }
43824 {
43825 PyThreadState* __tstate = wxPyBeginAllowThreads();
43826 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43827 wxPyEndAllowThreads(__tstate);
43828 if (PyErr_Occurred()) SWIG_fail;
43829 }
43830 resultobj = SWIG_Py_Void();
43831 {
43832 if (temp3)
43833 delete arg3;
43834 }
43835 return resultobj;
43836 fail:
43837 {
43838 if (temp3)
43839 delete arg3;
43840 }
43841 return NULL;
43842 }
43843
43844
43845 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43846 PyObject *resultobj = 0;
43847 wxMenu *arg1 = (wxMenu *) 0 ;
43848 int arg2 ;
43849 wxString result;
43850 void *argp1 = 0 ;
43851 int res1 = 0 ;
43852 int val2 ;
43853 int ecode2 = 0 ;
43854 PyObject * obj0 = 0 ;
43855 PyObject * obj1 = 0 ;
43856 char * kwnames[] = {
43857 (char *) "self",(char *) "id", NULL
43858 };
43859
43860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43862 if (!SWIG_IsOK(res1)) {
43863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43864 }
43865 arg1 = reinterpret_cast< wxMenu * >(argp1);
43866 ecode2 = SWIG_AsVal_int(obj1, &val2);
43867 if (!SWIG_IsOK(ecode2)) {
43868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43869 }
43870 arg2 = static_cast< int >(val2);
43871 {
43872 PyThreadState* __tstate = wxPyBeginAllowThreads();
43873 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43874 wxPyEndAllowThreads(__tstate);
43875 if (PyErr_Occurred()) SWIG_fail;
43876 }
43877 {
43878 #if wxUSE_UNICODE
43879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43880 #else
43881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43882 #endif
43883 }
43884 return resultobj;
43885 fail:
43886 return NULL;
43887 }
43888
43889
43890 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43891 PyObject *resultobj = 0;
43892 wxMenu *arg1 = (wxMenu *) 0 ;
43893 wxString *arg2 = 0 ;
43894 void *argp1 = 0 ;
43895 int res1 = 0 ;
43896 bool temp2 = false ;
43897 PyObject * obj0 = 0 ;
43898 PyObject * obj1 = 0 ;
43899 char * kwnames[] = {
43900 (char *) "self",(char *) "title", NULL
43901 };
43902
43903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43905 if (!SWIG_IsOK(res1)) {
43906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43907 }
43908 arg1 = reinterpret_cast< wxMenu * >(argp1);
43909 {
43910 arg2 = wxString_in_helper(obj1);
43911 if (arg2 == NULL) SWIG_fail;
43912 temp2 = true;
43913 }
43914 {
43915 PyThreadState* __tstate = wxPyBeginAllowThreads();
43916 (arg1)->SetTitle((wxString const &)*arg2);
43917 wxPyEndAllowThreads(__tstate);
43918 if (PyErr_Occurred()) SWIG_fail;
43919 }
43920 resultobj = SWIG_Py_Void();
43921 {
43922 if (temp2)
43923 delete arg2;
43924 }
43925 return resultobj;
43926 fail:
43927 {
43928 if (temp2)
43929 delete arg2;
43930 }
43931 return NULL;
43932 }
43933
43934
43935 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43936 PyObject *resultobj = 0;
43937 wxMenu *arg1 = (wxMenu *) 0 ;
43938 wxString result;
43939 void *argp1 = 0 ;
43940 int res1 = 0 ;
43941 PyObject *swig_obj[1] ;
43942
43943 if (!args) SWIG_fail;
43944 swig_obj[0] = args;
43945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43946 if (!SWIG_IsOK(res1)) {
43947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43948 }
43949 arg1 = reinterpret_cast< wxMenu * >(argp1);
43950 {
43951 PyThreadState* __tstate = wxPyBeginAllowThreads();
43952 result = ((wxMenu const *)arg1)->GetTitle();
43953 wxPyEndAllowThreads(__tstate);
43954 if (PyErr_Occurred()) SWIG_fail;
43955 }
43956 {
43957 #if wxUSE_UNICODE
43958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43959 #else
43960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43961 #endif
43962 }
43963 return resultobj;
43964 fail:
43965 return NULL;
43966 }
43967
43968
43969 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43970 PyObject *resultobj = 0;
43971 wxMenu *arg1 = (wxMenu *) 0 ;
43972 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43973 void *argp1 = 0 ;
43974 int res1 = 0 ;
43975 void *argp2 = 0 ;
43976 int res2 = 0 ;
43977 PyObject * obj0 = 0 ;
43978 PyObject * obj1 = 0 ;
43979 char * kwnames[] = {
43980 (char *) "self",(char *) "handler", NULL
43981 };
43982
43983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43985 if (!SWIG_IsOK(res1)) {
43986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43987 }
43988 arg1 = reinterpret_cast< wxMenu * >(argp1);
43989 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43990 if (!SWIG_IsOK(res2)) {
43991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43992 }
43993 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43994 {
43995 PyThreadState* __tstate = wxPyBeginAllowThreads();
43996 (arg1)->SetEventHandler(arg2);
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 resultobj = SWIG_Py_Void();
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44008 PyObject *resultobj = 0;
44009 wxMenu *arg1 = (wxMenu *) 0 ;
44010 wxEvtHandler *result = 0 ;
44011 void *argp1 = 0 ;
44012 int res1 = 0 ;
44013 PyObject *swig_obj[1] ;
44014
44015 if (!args) SWIG_fail;
44016 swig_obj[0] = args;
44017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44018 if (!SWIG_IsOK(res1)) {
44019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44020 }
44021 arg1 = reinterpret_cast< wxMenu * >(argp1);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 {
44029 resultobj = wxPyMake_wxObject(result, 0);
44030 }
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44038 PyObject *resultobj = 0;
44039 wxMenu *arg1 = (wxMenu *) 0 ;
44040 wxWindow *arg2 = (wxWindow *) 0 ;
44041 void *argp1 = 0 ;
44042 int res1 = 0 ;
44043 void *argp2 = 0 ;
44044 int res2 = 0 ;
44045 PyObject * obj0 = 0 ;
44046 PyObject * obj1 = 0 ;
44047 char * kwnames[] = {
44048 (char *) "self",(char *) "win", NULL
44049 };
44050
44051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44053 if (!SWIG_IsOK(res1)) {
44054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44055 }
44056 arg1 = reinterpret_cast< wxMenu * >(argp1);
44057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44058 if (!SWIG_IsOK(res2)) {
44059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44060 }
44061 arg2 = reinterpret_cast< wxWindow * >(argp2);
44062 {
44063 PyThreadState* __tstate = wxPyBeginAllowThreads();
44064 (arg1)->SetInvokingWindow(arg2);
44065 wxPyEndAllowThreads(__tstate);
44066 if (PyErr_Occurred()) SWIG_fail;
44067 }
44068 resultobj = SWIG_Py_Void();
44069 return resultobj;
44070 fail:
44071 return NULL;
44072 }
44073
44074
44075 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44076 PyObject *resultobj = 0;
44077 wxMenu *arg1 = (wxMenu *) 0 ;
44078 wxWindow *result = 0 ;
44079 void *argp1 = 0 ;
44080 int res1 = 0 ;
44081 PyObject *swig_obj[1] ;
44082
44083 if (!args) SWIG_fail;
44084 swig_obj[0] = args;
44085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44086 if (!SWIG_IsOK(res1)) {
44087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44088 }
44089 arg1 = reinterpret_cast< wxMenu * >(argp1);
44090 {
44091 PyThreadState* __tstate = wxPyBeginAllowThreads();
44092 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44093 wxPyEndAllowThreads(__tstate);
44094 if (PyErr_Occurred()) SWIG_fail;
44095 }
44096 {
44097 resultobj = wxPyMake_wxObject(result, 0);
44098 }
44099 return resultobj;
44100 fail:
44101 return NULL;
44102 }
44103
44104
44105 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44106 PyObject *resultobj = 0;
44107 wxMenu *arg1 = (wxMenu *) 0 ;
44108 long result;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 PyObject *swig_obj[1] ;
44112
44113 if (!args) SWIG_fail;
44114 swig_obj[0] = args;
44115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44116 if (!SWIG_IsOK(res1)) {
44117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44118 }
44119 arg1 = reinterpret_cast< wxMenu * >(argp1);
44120 {
44121 PyThreadState* __tstate = wxPyBeginAllowThreads();
44122 result = (long)((wxMenu const *)arg1)->GetStyle();
44123 wxPyEndAllowThreads(__tstate);
44124 if (PyErr_Occurred()) SWIG_fail;
44125 }
44126 resultobj = SWIG_From_long(static_cast< long >(result));
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44134 PyObject *resultobj = 0;
44135 wxMenu *arg1 = (wxMenu *) 0 ;
44136 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44137 void *argp1 = 0 ;
44138 int res1 = 0 ;
44139 void *argp2 = 0 ;
44140 int res2 = 0 ;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143 char * kwnames[] = {
44144 (char *) "self",(char *) "source", NULL
44145 };
44146
44147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44149 if (!SWIG_IsOK(res1)) {
44150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44151 }
44152 arg1 = reinterpret_cast< wxMenu * >(argp1);
44153 if (obj1) {
44154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44155 if (!SWIG_IsOK(res2)) {
44156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44157 }
44158 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44159 }
44160 {
44161 PyThreadState* __tstate = wxPyBeginAllowThreads();
44162 (arg1)->UpdateUI(arg2);
44163 wxPyEndAllowThreads(__tstate);
44164 if (PyErr_Occurred()) SWIG_fail;
44165 }
44166 resultobj = SWIG_Py_Void();
44167 return resultobj;
44168 fail:
44169 return NULL;
44170 }
44171
44172
44173 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44174 PyObject *resultobj = 0;
44175 wxMenu *arg1 = (wxMenu *) 0 ;
44176 wxMenuBar *result = 0 ;
44177 void *argp1 = 0 ;
44178 int res1 = 0 ;
44179 PyObject *swig_obj[1] ;
44180
44181 if (!args) SWIG_fail;
44182 swig_obj[0] = args;
44183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44184 if (!SWIG_IsOK(res1)) {
44185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44186 }
44187 arg1 = reinterpret_cast< wxMenu * >(argp1);
44188 {
44189 PyThreadState* __tstate = wxPyBeginAllowThreads();
44190 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44191 wxPyEndAllowThreads(__tstate);
44192 if (PyErr_Occurred()) SWIG_fail;
44193 }
44194 {
44195 resultobj = wxPyMake_wxObject(result, (bool)0);
44196 }
44197 return resultobj;
44198 fail:
44199 return NULL;
44200 }
44201
44202
44203 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44204 PyObject *resultobj = 0;
44205 wxMenu *arg1 = (wxMenu *) 0 ;
44206 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44207 void *argp1 = 0 ;
44208 int res1 = 0 ;
44209 void *argp2 = 0 ;
44210 int res2 = 0 ;
44211 PyObject * obj0 = 0 ;
44212 PyObject * obj1 = 0 ;
44213 char * kwnames[] = {
44214 (char *) "self",(char *) "menubar", NULL
44215 };
44216
44217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44219 if (!SWIG_IsOK(res1)) {
44220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44221 }
44222 arg1 = reinterpret_cast< wxMenu * >(argp1);
44223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44224 if (!SWIG_IsOK(res2)) {
44225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44226 }
44227 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 (arg1)->Attach(arg2);
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 resultobj = SWIG_Py_Void();
44235 return resultobj;
44236 fail:
44237 return NULL;
44238 }
44239
44240
44241 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44242 PyObject *resultobj = 0;
44243 wxMenu *arg1 = (wxMenu *) 0 ;
44244 void *argp1 = 0 ;
44245 int res1 = 0 ;
44246 PyObject *swig_obj[1] ;
44247
44248 if (!args) SWIG_fail;
44249 swig_obj[0] = args;
44250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44251 if (!SWIG_IsOK(res1)) {
44252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44253 }
44254 arg1 = reinterpret_cast< wxMenu * >(argp1);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 (arg1)->Detach();
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 resultobj = SWIG_Py_Void();
44262 return resultobj;
44263 fail:
44264 return NULL;
44265 }
44266
44267
44268 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44269 PyObject *resultobj = 0;
44270 wxMenu *arg1 = (wxMenu *) 0 ;
44271 bool result;
44272 void *argp1 = 0 ;
44273 int res1 = 0 ;
44274 PyObject *swig_obj[1] ;
44275
44276 if (!args) SWIG_fail;
44277 swig_obj[0] = args;
44278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44279 if (!SWIG_IsOK(res1)) {
44280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44281 }
44282 arg1 = reinterpret_cast< wxMenu * >(argp1);
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 result = (bool)((wxMenu const *)arg1)->IsAttached();
44286 wxPyEndAllowThreads(__tstate);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 }
44289 {
44290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44291 }
44292 return resultobj;
44293 fail:
44294 return NULL;
44295 }
44296
44297
44298 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44299 PyObject *resultobj = 0;
44300 wxMenu *arg1 = (wxMenu *) 0 ;
44301 wxMenu *arg2 = (wxMenu *) 0 ;
44302 void *argp1 = 0 ;
44303 int res1 = 0 ;
44304 void *argp2 = 0 ;
44305 int res2 = 0 ;
44306 PyObject * obj0 = 0 ;
44307 PyObject * obj1 = 0 ;
44308 char * kwnames[] = {
44309 (char *) "self",(char *) "parent", NULL
44310 };
44311
44312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44314 if (!SWIG_IsOK(res1)) {
44315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44316 }
44317 arg1 = reinterpret_cast< wxMenu * >(argp1);
44318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44319 if (!SWIG_IsOK(res2)) {
44320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44321 }
44322 arg2 = reinterpret_cast< wxMenu * >(argp2);
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 (arg1)->SetParent(arg2);
44326 wxPyEndAllowThreads(__tstate);
44327 if (PyErr_Occurred()) SWIG_fail;
44328 }
44329 resultobj = SWIG_Py_Void();
44330 return resultobj;
44331 fail:
44332 return NULL;
44333 }
44334
44335
44336 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44337 PyObject *resultobj = 0;
44338 wxMenu *arg1 = (wxMenu *) 0 ;
44339 wxMenu *result = 0 ;
44340 void *argp1 = 0 ;
44341 int res1 = 0 ;
44342 PyObject *swig_obj[1] ;
44343
44344 if (!args) SWIG_fail;
44345 swig_obj[0] = args;
44346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44349 }
44350 arg1 = reinterpret_cast< wxMenu * >(argp1);
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44354 wxPyEndAllowThreads(__tstate);
44355 if (PyErr_Occurred()) SWIG_fail;
44356 }
44357 {
44358 resultobj = wxPyMake_wxObject(result, 0);
44359 }
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44367 PyObject *obj;
44368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44369 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44370 return SWIG_Py_Void();
44371 }
44372
44373 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44374 return SWIG_Python_InitShadowInstance(args);
44375 }
44376
44377 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44378 PyObject *resultobj = 0;
44379 long arg1 = (long) 0 ;
44380 wxMenuBar *result = 0 ;
44381 long val1 ;
44382 int ecode1 = 0 ;
44383 PyObject * obj0 = 0 ;
44384 char * kwnames[] = {
44385 (char *) "style", NULL
44386 };
44387
44388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44389 if (obj0) {
44390 ecode1 = SWIG_AsVal_long(obj0, &val1);
44391 if (!SWIG_IsOK(ecode1)) {
44392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44393 }
44394 arg1 = static_cast< long >(val1);
44395 }
44396 {
44397 if (!wxPyCheckForApp()) SWIG_fail;
44398 PyThreadState* __tstate = wxPyBeginAllowThreads();
44399 result = (wxMenuBar *)new wxMenuBar(arg1);
44400 wxPyEndAllowThreads(__tstate);
44401 if (PyErr_Occurred()) SWIG_fail;
44402 }
44403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44404 return resultobj;
44405 fail:
44406 return NULL;
44407 }
44408
44409
44410 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44411 PyObject *resultobj = 0;
44412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44413 wxMenu *arg2 = (wxMenu *) 0 ;
44414 wxString *arg3 = 0 ;
44415 bool result;
44416 void *argp1 = 0 ;
44417 int res1 = 0 ;
44418 void *argp2 = 0 ;
44419 int res2 = 0 ;
44420 bool temp3 = false ;
44421 PyObject * obj0 = 0 ;
44422 PyObject * obj1 = 0 ;
44423 PyObject * obj2 = 0 ;
44424 char * kwnames[] = {
44425 (char *) "self",(char *) "menu",(char *) "title", NULL
44426 };
44427
44428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44430 if (!SWIG_IsOK(res1)) {
44431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44432 }
44433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44435 if (!SWIG_IsOK(res2)) {
44436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44437 }
44438 arg2 = reinterpret_cast< wxMenu * >(argp2);
44439 {
44440 arg3 = wxString_in_helper(obj2);
44441 if (arg3 == NULL) SWIG_fail;
44442 temp3 = true;
44443 }
44444 {
44445 PyThreadState* __tstate = wxPyBeginAllowThreads();
44446 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 {
44451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44452 }
44453 {
44454 if (temp3)
44455 delete arg3;
44456 }
44457 return resultobj;
44458 fail:
44459 {
44460 if (temp3)
44461 delete arg3;
44462 }
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44468 PyObject *resultobj = 0;
44469 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44470 size_t arg2 ;
44471 wxMenu *arg3 = (wxMenu *) 0 ;
44472 wxString *arg4 = 0 ;
44473 bool result;
44474 void *argp1 = 0 ;
44475 int res1 = 0 ;
44476 size_t val2 ;
44477 int ecode2 = 0 ;
44478 void *argp3 = 0 ;
44479 int res3 = 0 ;
44480 bool temp4 = false ;
44481 PyObject * obj0 = 0 ;
44482 PyObject * obj1 = 0 ;
44483 PyObject * obj2 = 0 ;
44484 PyObject * obj3 = 0 ;
44485 char * kwnames[] = {
44486 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44487 };
44488
44489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44491 if (!SWIG_IsOK(res1)) {
44492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44493 }
44494 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44495 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44496 if (!SWIG_IsOK(ecode2)) {
44497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44498 }
44499 arg2 = static_cast< size_t >(val2);
44500 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44501 if (!SWIG_IsOK(res3)) {
44502 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44503 }
44504 arg3 = reinterpret_cast< wxMenu * >(argp3);
44505 {
44506 arg4 = wxString_in_helper(obj3);
44507 if (arg4 == NULL) SWIG_fail;
44508 temp4 = true;
44509 }
44510 {
44511 PyThreadState* __tstate = wxPyBeginAllowThreads();
44512 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44513 wxPyEndAllowThreads(__tstate);
44514 if (PyErr_Occurred()) SWIG_fail;
44515 }
44516 {
44517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44518 }
44519 {
44520 if (temp4)
44521 delete arg4;
44522 }
44523 return resultobj;
44524 fail:
44525 {
44526 if (temp4)
44527 delete arg4;
44528 }
44529 return NULL;
44530 }
44531
44532
44533 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44534 PyObject *resultobj = 0;
44535 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44536 size_t result;
44537 void *argp1 = 0 ;
44538 int res1 = 0 ;
44539 PyObject *swig_obj[1] ;
44540
44541 if (!args) SWIG_fail;
44542 swig_obj[0] = args;
44543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44544 if (!SWIG_IsOK(res1)) {
44545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44546 }
44547 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44548 {
44549 PyThreadState* __tstate = wxPyBeginAllowThreads();
44550 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44551 wxPyEndAllowThreads(__tstate);
44552 if (PyErr_Occurred()) SWIG_fail;
44553 }
44554 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44562 PyObject *resultobj = 0;
44563 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44564 size_t arg2 ;
44565 wxMenu *result = 0 ;
44566 void *argp1 = 0 ;
44567 int res1 = 0 ;
44568 size_t val2 ;
44569 int ecode2 = 0 ;
44570 PyObject * obj0 = 0 ;
44571 PyObject * obj1 = 0 ;
44572 char * kwnames[] = {
44573 (char *) "self",(char *) "pos", NULL
44574 };
44575
44576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44578 if (!SWIG_IsOK(res1)) {
44579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44580 }
44581 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44582 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44583 if (!SWIG_IsOK(ecode2)) {
44584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44585 }
44586 arg2 = static_cast< size_t >(val2);
44587 {
44588 PyThreadState* __tstate = wxPyBeginAllowThreads();
44589 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44590 wxPyEndAllowThreads(__tstate);
44591 if (PyErr_Occurred()) SWIG_fail;
44592 }
44593 {
44594 resultobj = wxPyMake_wxObject(result, 0);
44595 }
44596 return resultobj;
44597 fail:
44598 return NULL;
44599 }
44600
44601
44602 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44603 PyObject *resultobj = 0;
44604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44605 size_t arg2 ;
44606 wxMenu *arg3 = (wxMenu *) 0 ;
44607 wxString *arg4 = 0 ;
44608 wxMenu *result = 0 ;
44609 void *argp1 = 0 ;
44610 int res1 = 0 ;
44611 size_t val2 ;
44612 int ecode2 = 0 ;
44613 void *argp3 = 0 ;
44614 int res3 = 0 ;
44615 bool temp4 = false ;
44616 PyObject * obj0 = 0 ;
44617 PyObject * obj1 = 0 ;
44618 PyObject * obj2 = 0 ;
44619 PyObject * obj3 = 0 ;
44620 char * kwnames[] = {
44621 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44622 };
44623
44624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44626 if (!SWIG_IsOK(res1)) {
44627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44628 }
44629 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44630 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44631 if (!SWIG_IsOK(ecode2)) {
44632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44633 }
44634 arg2 = static_cast< size_t >(val2);
44635 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44636 if (!SWIG_IsOK(res3)) {
44637 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44638 }
44639 arg3 = reinterpret_cast< wxMenu * >(argp3);
44640 {
44641 arg4 = wxString_in_helper(obj3);
44642 if (arg4 == NULL) SWIG_fail;
44643 temp4 = true;
44644 }
44645 {
44646 PyThreadState* __tstate = wxPyBeginAllowThreads();
44647 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44648 wxPyEndAllowThreads(__tstate);
44649 if (PyErr_Occurred()) SWIG_fail;
44650 }
44651 {
44652 resultobj = wxPyMake_wxObject(result, 0);
44653 }
44654 {
44655 if (temp4)
44656 delete arg4;
44657 }
44658 return resultobj;
44659 fail:
44660 {
44661 if (temp4)
44662 delete arg4;
44663 }
44664 return NULL;
44665 }
44666
44667
44668 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44669 PyObject *resultobj = 0;
44670 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44671 size_t arg2 ;
44672 wxMenu *result = 0 ;
44673 void *argp1 = 0 ;
44674 int res1 = 0 ;
44675 size_t val2 ;
44676 int ecode2 = 0 ;
44677 PyObject * obj0 = 0 ;
44678 PyObject * obj1 = 0 ;
44679 char * kwnames[] = {
44680 (char *) "self",(char *) "pos", NULL
44681 };
44682
44683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44685 if (!SWIG_IsOK(res1)) {
44686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44687 }
44688 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44689 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44690 if (!SWIG_IsOK(ecode2)) {
44691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44692 }
44693 arg2 = static_cast< size_t >(val2);
44694 {
44695 PyThreadState* __tstate = wxPyBeginAllowThreads();
44696 result = (wxMenu *)(arg1)->Remove(arg2);
44697 wxPyEndAllowThreads(__tstate);
44698 if (PyErr_Occurred()) SWIG_fail;
44699 }
44700 {
44701 resultobj = wxPyMake_wxObject(result, 0);
44702 }
44703 return resultobj;
44704 fail:
44705 return NULL;
44706 }
44707
44708
44709 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44710 PyObject *resultobj = 0;
44711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44712 size_t arg2 ;
44713 bool arg3 ;
44714 void *argp1 = 0 ;
44715 int res1 = 0 ;
44716 size_t val2 ;
44717 int ecode2 = 0 ;
44718 bool val3 ;
44719 int ecode3 = 0 ;
44720 PyObject * obj0 = 0 ;
44721 PyObject * obj1 = 0 ;
44722 PyObject * obj2 = 0 ;
44723 char * kwnames[] = {
44724 (char *) "self",(char *) "pos",(char *) "enable", NULL
44725 };
44726
44727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44729 if (!SWIG_IsOK(res1)) {
44730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44731 }
44732 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44733 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44734 if (!SWIG_IsOK(ecode2)) {
44735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44736 }
44737 arg2 = static_cast< size_t >(val2);
44738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44739 if (!SWIG_IsOK(ecode3)) {
44740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44741 }
44742 arg3 = static_cast< bool >(val3);
44743 {
44744 PyThreadState* __tstate = wxPyBeginAllowThreads();
44745 (arg1)->EnableTop(arg2,arg3);
44746 wxPyEndAllowThreads(__tstate);
44747 if (PyErr_Occurred()) SWIG_fail;
44748 }
44749 resultobj = SWIG_Py_Void();
44750 return resultobj;
44751 fail:
44752 return NULL;
44753 }
44754
44755
44756 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44757 PyObject *resultobj = 0;
44758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44759 size_t arg2 ;
44760 bool result;
44761 void *argp1 = 0 ;
44762 int res1 = 0 ;
44763 size_t val2 ;
44764 int ecode2 = 0 ;
44765 PyObject * obj0 = 0 ;
44766 PyObject * obj1 = 0 ;
44767 char * kwnames[] = {
44768 (char *) "self",(char *) "pos", NULL
44769 };
44770
44771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44773 if (!SWIG_IsOK(res1)) {
44774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44775 }
44776 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44777 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44778 if (!SWIG_IsOK(ecode2)) {
44779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44780 }
44781 arg2 = static_cast< size_t >(val2);
44782 {
44783 PyThreadState* __tstate = wxPyBeginAllowThreads();
44784 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44785 wxPyEndAllowThreads(__tstate);
44786 if (PyErr_Occurred()) SWIG_fail;
44787 }
44788 {
44789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44790 }
44791 return resultobj;
44792 fail:
44793 return NULL;
44794 }
44795
44796
44797 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44798 PyObject *resultobj = 0;
44799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44800 size_t arg2 ;
44801 wxString *arg3 = 0 ;
44802 void *argp1 = 0 ;
44803 int res1 = 0 ;
44804 size_t val2 ;
44805 int ecode2 = 0 ;
44806 bool temp3 = false ;
44807 PyObject * obj0 = 0 ;
44808 PyObject * obj1 = 0 ;
44809 PyObject * obj2 = 0 ;
44810 char * kwnames[] = {
44811 (char *) "self",(char *) "pos",(char *) "label", NULL
44812 };
44813
44814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44816 if (!SWIG_IsOK(res1)) {
44817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44818 }
44819 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44821 if (!SWIG_IsOK(ecode2)) {
44822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44823 }
44824 arg2 = static_cast< size_t >(val2);
44825 {
44826 arg3 = wxString_in_helper(obj2);
44827 if (arg3 == NULL) SWIG_fail;
44828 temp3 = true;
44829 }
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 resultobj = SWIG_Py_Void();
44837 {
44838 if (temp3)
44839 delete arg3;
44840 }
44841 return resultobj;
44842 fail:
44843 {
44844 if (temp3)
44845 delete arg3;
44846 }
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44852 PyObject *resultobj = 0;
44853 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44854 size_t arg2 ;
44855 wxString result;
44856 void *argp1 = 0 ;
44857 int res1 = 0 ;
44858 size_t val2 ;
44859 int ecode2 = 0 ;
44860 PyObject * obj0 = 0 ;
44861 PyObject * obj1 = 0 ;
44862 char * kwnames[] = {
44863 (char *) "self",(char *) "pos", NULL
44864 };
44865
44866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44868 if (!SWIG_IsOK(res1)) {
44869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44870 }
44871 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44872 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44873 if (!SWIG_IsOK(ecode2)) {
44874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44875 }
44876 arg2 = static_cast< size_t >(val2);
44877 {
44878 PyThreadState* __tstate = wxPyBeginAllowThreads();
44879 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44880 wxPyEndAllowThreads(__tstate);
44881 if (PyErr_Occurred()) SWIG_fail;
44882 }
44883 {
44884 #if wxUSE_UNICODE
44885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44886 #else
44887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44888 #endif
44889 }
44890 return resultobj;
44891 fail:
44892 return NULL;
44893 }
44894
44895
44896 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44897 PyObject *resultobj = 0;
44898 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44899 wxString *arg2 = 0 ;
44900 wxString *arg3 = 0 ;
44901 int result;
44902 void *argp1 = 0 ;
44903 int res1 = 0 ;
44904 bool temp2 = false ;
44905 bool temp3 = false ;
44906 PyObject * obj0 = 0 ;
44907 PyObject * obj1 = 0 ;
44908 PyObject * obj2 = 0 ;
44909 char * kwnames[] = {
44910 (char *) "self",(char *) "menu",(char *) "item", NULL
44911 };
44912
44913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44915 if (!SWIG_IsOK(res1)) {
44916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44917 }
44918 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44919 {
44920 arg2 = wxString_in_helper(obj1);
44921 if (arg2 == NULL) SWIG_fail;
44922 temp2 = true;
44923 }
44924 {
44925 arg3 = wxString_in_helper(obj2);
44926 if (arg3 == NULL) SWIG_fail;
44927 temp3 = true;
44928 }
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44932 wxPyEndAllowThreads(__tstate);
44933 if (PyErr_Occurred()) SWIG_fail;
44934 }
44935 resultobj = SWIG_From_int(static_cast< int >(result));
44936 {
44937 if (temp2)
44938 delete arg2;
44939 }
44940 {
44941 if (temp3)
44942 delete arg3;
44943 }
44944 return resultobj;
44945 fail:
44946 {
44947 if (temp2)
44948 delete arg2;
44949 }
44950 {
44951 if (temp3)
44952 delete arg3;
44953 }
44954 return NULL;
44955 }
44956
44957
44958 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44959 PyObject *resultobj = 0;
44960 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44961 int arg2 ;
44962 wxMenuItem *result = 0 ;
44963 void *argp1 = 0 ;
44964 int res1 = 0 ;
44965 int val2 ;
44966 int ecode2 = 0 ;
44967 PyObject * obj0 = 0 ;
44968 PyObject * obj1 = 0 ;
44969 char * kwnames[] = {
44970 (char *) "self",(char *) "id", NULL
44971 };
44972
44973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44975 if (!SWIG_IsOK(res1)) {
44976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44977 }
44978 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44979 ecode2 = SWIG_AsVal_int(obj1, &val2);
44980 if (!SWIG_IsOK(ecode2)) {
44981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44982 }
44983 arg2 = static_cast< int >(val2);
44984 {
44985 PyThreadState* __tstate = wxPyBeginAllowThreads();
44986 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44987 wxPyEndAllowThreads(__tstate);
44988 if (PyErr_Occurred()) SWIG_fail;
44989 }
44990 {
44991 resultobj = wxPyMake_wxObject(result, (bool)0);
44992 }
44993 return resultobj;
44994 fail:
44995 return NULL;
44996 }
44997
44998
44999 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45000 PyObject *resultobj = 0;
45001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45002 wxString *arg2 = 0 ;
45003 int result;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 bool temp2 = false ;
45007 PyObject * obj0 = 0 ;
45008 PyObject * obj1 = 0 ;
45009 char * kwnames[] = {
45010 (char *) "self",(char *) "title", NULL
45011 };
45012
45013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45015 if (!SWIG_IsOK(res1)) {
45016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45017 }
45018 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45019 {
45020 arg2 = wxString_in_helper(obj1);
45021 if (arg2 == NULL) SWIG_fail;
45022 temp2 = true;
45023 }
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_From_int(static_cast< int >(result));
45031 {
45032 if (temp2)
45033 delete arg2;
45034 }
45035 return resultobj;
45036 fail:
45037 {
45038 if (temp2)
45039 delete arg2;
45040 }
45041 return NULL;
45042 }
45043
45044
45045 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45046 PyObject *resultobj = 0;
45047 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45048 int arg2 ;
45049 bool arg3 ;
45050 void *argp1 = 0 ;
45051 int res1 = 0 ;
45052 int val2 ;
45053 int ecode2 = 0 ;
45054 bool val3 ;
45055 int ecode3 = 0 ;
45056 PyObject * obj0 = 0 ;
45057 PyObject * obj1 = 0 ;
45058 PyObject * obj2 = 0 ;
45059 char * kwnames[] = {
45060 (char *) "self",(char *) "id",(char *) "enable", NULL
45061 };
45062
45063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45065 if (!SWIG_IsOK(res1)) {
45066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45067 }
45068 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45069 ecode2 = SWIG_AsVal_int(obj1, &val2);
45070 if (!SWIG_IsOK(ecode2)) {
45071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45072 }
45073 arg2 = static_cast< int >(val2);
45074 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45075 if (!SWIG_IsOK(ecode3)) {
45076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45077 }
45078 arg3 = static_cast< bool >(val3);
45079 {
45080 PyThreadState* __tstate = wxPyBeginAllowThreads();
45081 (arg1)->Enable(arg2,arg3);
45082 wxPyEndAllowThreads(__tstate);
45083 if (PyErr_Occurred()) SWIG_fail;
45084 }
45085 resultobj = SWIG_Py_Void();
45086 return resultobj;
45087 fail:
45088 return NULL;
45089 }
45090
45091
45092 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45093 PyObject *resultobj = 0;
45094 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45095 int arg2 ;
45096 bool arg3 ;
45097 void *argp1 = 0 ;
45098 int res1 = 0 ;
45099 int val2 ;
45100 int ecode2 = 0 ;
45101 bool val3 ;
45102 int ecode3 = 0 ;
45103 PyObject * obj0 = 0 ;
45104 PyObject * obj1 = 0 ;
45105 PyObject * obj2 = 0 ;
45106 char * kwnames[] = {
45107 (char *) "self",(char *) "id",(char *) "check", NULL
45108 };
45109
45110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45112 if (!SWIG_IsOK(res1)) {
45113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45114 }
45115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45116 ecode2 = SWIG_AsVal_int(obj1, &val2);
45117 if (!SWIG_IsOK(ecode2)) {
45118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45119 }
45120 arg2 = static_cast< int >(val2);
45121 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45122 if (!SWIG_IsOK(ecode3)) {
45123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45124 }
45125 arg3 = static_cast< bool >(val3);
45126 {
45127 PyThreadState* __tstate = wxPyBeginAllowThreads();
45128 (arg1)->Check(arg2,arg3);
45129 wxPyEndAllowThreads(__tstate);
45130 if (PyErr_Occurred()) SWIG_fail;
45131 }
45132 resultobj = SWIG_Py_Void();
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj = 0;
45141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45142 int arg2 ;
45143 bool result;
45144 void *argp1 = 0 ;
45145 int res1 = 0 ;
45146 int val2 ;
45147 int ecode2 = 0 ;
45148 PyObject * obj0 = 0 ;
45149 PyObject * obj1 = 0 ;
45150 char * kwnames[] = {
45151 (char *) "self",(char *) "id", NULL
45152 };
45153
45154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45156 if (!SWIG_IsOK(res1)) {
45157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45158 }
45159 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45160 ecode2 = SWIG_AsVal_int(obj1, &val2);
45161 if (!SWIG_IsOK(ecode2)) {
45162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45163 }
45164 arg2 = static_cast< int >(val2);
45165 {
45166 PyThreadState* __tstate = wxPyBeginAllowThreads();
45167 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45168 wxPyEndAllowThreads(__tstate);
45169 if (PyErr_Occurred()) SWIG_fail;
45170 }
45171 {
45172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45173 }
45174 return resultobj;
45175 fail:
45176 return NULL;
45177 }
45178
45179
45180 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45181 PyObject *resultobj = 0;
45182 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45183 int arg2 ;
45184 bool result;
45185 void *argp1 = 0 ;
45186 int res1 = 0 ;
45187 int val2 ;
45188 int ecode2 = 0 ;
45189 PyObject * obj0 = 0 ;
45190 PyObject * obj1 = 0 ;
45191 char * kwnames[] = {
45192 (char *) "self",(char *) "id", NULL
45193 };
45194
45195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45197 if (!SWIG_IsOK(res1)) {
45198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45199 }
45200 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45201 ecode2 = SWIG_AsVal_int(obj1, &val2);
45202 if (!SWIG_IsOK(ecode2)) {
45203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45204 }
45205 arg2 = static_cast< int >(val2);
45206 {
45207 PyThreadState* __tstate = wxPyBeginAllowThreads();
45208 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45209 wxPyEndAllowThreads(__tstate);
45210 if (PyErr_Occurred()) SWIG_fail;
45211 }
45212 {
45213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45214 }
45215 return resultobj;
45216 fail:
45217 return NULL;
45218 }
45219
45220
45221 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45222 PyObject *resultobj = 0;
45223 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45224 int arg2 ;
45225 wxString *arg3 = 0 ;
45226 void *argp1 = 0 ;
45227 int res1 = 0 ;
45228 int val2 ;
45229 int ecode2 = 0 ;
45230 bool temp3 = false ;
45231 PyObject * obj0 = 0 ;
45232 PyObject * obj1 = 0 ;
45233 PyObject * obj2 = 0 ;
45234 char * kwnames[] = {
45235 (char *) "self",(char *) "id",(char *) "label", NULL
45236 };
45237
45238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45240 if (!SWIG_IsOK(res1)) {
45241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45242 }
45243 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45244 ecode2 = SWIG_AsVal_int(obj1, &val2);
45245 if (!SWIG_IsOK(ecode2)) {
45246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45247 }
45248 arg2 = static_cast< int >(val2);
45249 {
45250 arg3 = wxString_in_helper(obj2);
45251 if (arg3 == NULL) SWIG_fail;
45252 temp3 = true;
45253 }
45254 {
45255 PyThreadState* __tstate = wxPyBeginAllowThreads();
45256 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45257 wxPyEndAllowThreads(__tstate);
45258 if (PyErr_Occurred()) SWIG_fail;
45259 }
45260 resultobj = SWIG_Py_Void();
45261 {
45262 if (temp3)
45263 delete arg3;
45264 }
45265 return resultobj;
45266 fail:
45267 {
45268 if (temp3)
45269 delete arg3;
45270 }
45271 return NULL;
45272 }
45273
45274
45275 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45276 PyObject *resultobj = 0;
45277 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45278 int arg2 ;
45279 wxString result;
45280 void *argp1 = 0 ;
45281 int res1 = 0 ;
45282 int val2 ;
45283 int ecode2 = 0 ;
45284 PyObject * obj0 = 0 ;
45285 PyObject * obj1 = 0 ;
45286 char * kwnames[] = {
45287 (char *) "self",(char *) "id", NULL
45288 };
45289
45290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45292 if (!SWIG_IsOK(res1)) {
45293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45294 }
45295 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45296 ecode2 = SWIG_AsVal_int(obj1, &val2);
45297 if (!SWIG_IsOK(ecode2)) {
45298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45299 }
45300 arg2 = static_cast< int >(val2);
45301 {
45302 PyThreadState* __tstate = wxPyBeginAllowThreads();
45303 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45304 wxPyEndAllowThreads(__tstate);
45305 if (PyErr_Occurred()) SWIG_fail;
45306 }
45307 {
45308 #if wxUSE_UNICODE
45309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45310 #else
45311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45312 #endif
45313 }
45314 return resultobj;
45315 fail:
45316 return NULL;
45317 }
45318
45319
45320 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45321 PyObject *resultobj = 0;
45322 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45323 int arg2 ;
45324 wxString *arg3 = 0 ;
45325 void *argp1 = 0 ;
45326 int res1 = 0 ;
45327 int val2 ;
45328 int ecode2 = 0 ;
45329 bool temp3 = false ;
45330 PyObject * obj0 = 0 ;
45331 PyObject * obj1 = 0 ;
45332 PyObject * obj2 = 0 ;
45333 char * kwnames[] = {
45334 (char *) "self",(char *) "id",(char *) "helpString", NULL
45335 };
45336
45337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45339 if (!SWIG_IsOK(res1)) {
45340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45341 }
45342 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45343 ecode2 = SWIG_AsVal_int(obj1, &val2);
45344 if (!SWIG_IsOK(ecode2)) {
45345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45346 }
45347 arg2 = static_cast< int >(val2);
45348 {
45349 arg3 = wxString_in_helper(obj2);
45350 if (arg3 == NULL) SWIG_fail;
45351 temp3 = true;
45352 }
45353 {
45354 PyThreadState* __tstate = wxPyBeginAllowThreads();
45355 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45356 wxPyEndAllowThreads(__tstate);
45357 if (PyErr_Occurred()) SWIG_fail;
45358 }
45359 resultobj = SWIG_Py_Void();
45360 {
45361 if (temp3)
45362 delete arg3;
45363 }
45364 return resultobj;
45365 fail:
45366 {
45367 if (temp3)
45368 delete arg3;
45369 }
45370 return NULL;
45371 }
45372
45373
45374 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45375 PyObject *resultobj = 0;
45376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45377 int arg2 ;
45378 wxString result;
45379 void *argp1 = 0 ;
45380 int res1 = 0 ;
45381 int val2 ;
45382 int ecode2 = 0 ;
45383 PyObject * obj0 = 0 ;
45384 PyObject * obj1 = 0 ;
45385 char * kwnames[] = {
45386 (char *) "self",(char *) "id", NULL
45387 };
45388
45389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45391 if (!SWIG_IsOK(res1)) {
45392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45393 }
45394 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45395 ecode2 = SWIG_AsVal_int(obj1, &val2);
45396 if (!SWIG_IsOK(ecode2)) {
45397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45398 }
45399 arg2 = static_cast< int >(val2);
45400 {
45401 PyThreadState* __tstate = wxPyBeginAllowThreads();
45402 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45403 wxPyEndAllowThreads(__tstate);
45404 if (PyErr_Occurred()) SWIG_fail;
45405 }
45406 {
45407 #if wxUSE_UNICODE
45408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45409 #else
45410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45411 #endif
45412 }
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45420 PyObject *resultobj = 0;
45421 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45422 wxFrame *result = 0 ;
45423 void *argp1 = 0 ;
45424 int res1 = 0 ;
45425 PyObject *swig_obj[1] ;
45426
45427 if (!args) SWIG_fail;
45428 swig_obj[0] = args;
45429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45430 if (!SWIG_IsOK(res1)) {
45431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45432 }
45433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45434 {
45435 PyThreadState* __tstate = wxPyBeginAllowThreads();
45436 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45437 wxPyEndAllowThreads(__tstate);
45438 if (PyErr_Occurred()) SWIG_fail;
45439 }
45440 {
45441 resultobj = wxPyMake_wxObject(result, (bool)0);
45442 }
45443 return resultobj;
45444 fail:
45445 return NULL;
45446 }
45447
45448
45449 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45450 PyObject *resultobj = 0;
45451 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45452 bool result;
45453 void *argp1 = 0 ;
45454 int res1 = 0 ;
45455 PyObject *swig_obj[1] ;
45456
45457 if (!args) SWIG_fail;
45458 swig_obj[0] = args;
45459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45460 if (!SWIG_IsOK(res1)) {
45461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45462 }
45463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 {
45471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45472 }
45473 return resultobj;
45474 fail:
45475 return NULL;
45476 }
45477
45478
45479 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45480 PyObject *resultobj = 0;
45481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45482 wxFrame *arg2 = (wxFrame *) 0 ;
45483 void *argp1 = 0 ;
45484 int res1 = 0 ;
45485 void *argp2 = 0 ;
45486 int res2 = 0 ;
45487 PyObject * obj0 = 0 ;
45488 PyObject * obj1 = 0 ;
45489 char * kwnames[] = {
45490 (char *) "self",(char *) "frame", NULL
45491 };
45492
45493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45495 if (!SWIG_IsOK(res1)) {
45496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45497 }
45498 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45500 if (!SWIG_IsOK(res2)) {
45501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45502 }
45503 arg2 = reinterpret_cast< wxFrame * >(argp2);
45504 {
45505 PyThreadState* __tstate = wxPyBeginAllowThreads();
45506 (arg1)->Attach(arg2);
45507 wxPyEndAllowThreads(__tstate);
45508 if (PyErr_Occurred()) SWIG_fail;
45509 }
45510 resultobj = SWIG_Py_Void();
45511 return resultobj;
45512 fail:
45513 return NULL;
45514 }
45515
45516
45517 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45518 PyObject *resultobj = 0;
45519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45520 void *argp1 = 0 ;
45521 int res1 = 0 ;
45522 PyObject *swig_obj[1] ;
45523
45524 if (!args) SWIG_fail;
45525 swig_obj[0] = args;
45526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45527 if (!SWIG_IsOK(res1)) {
45528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45529 }
45530 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45531 {
45532 PyThreadState* __tstate = wxPyBeginAllowThreads();
45533 (arg1)->Detach();
45534 wxPyEndAllowThreads(__tstate);
45535 if (PyErr_Occurred()) SWIG_fail;
45536 }
45537 resultobj = SWIG_Py_Void();
45538 return resultobj;
45539 fail:
45540 return NULL;
45541 }
45542
45543
45544 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45545 PyObject *resultobj = 0;
45546 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45547 void *argp1 = 0 ;
45548 int res1 = 0 ;
45549 PyObject *swig_obj[1] ;
45550
45551 if (!args) SWIG_fail;
45552 swig_obj[0] = args;
45553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45554 if (!SWIG_IsOK(res1)) {
45555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45556 }
45557 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45558 {
45559 PyThreadState* __tstate = wxPyBeginAllowThreads();
45560 (arg1)->UpdateMenus();
45561 wxPyEndAllowThreads(__tstate);
45562 if (PyErr_Occurred()) SWIG_fail;
45563 }
45564 resultobj = SWIG_Py_Void();
45565 return resultobj;
45566 fail:
45567 return NULL;
45568 }
45569
45570
45571 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45572 PyObject *resultobj = 0;
45573 bool arg1 ;
45574 bool val1 ;
45575 int ecode1 = 0 ;
45576 PyObject * obj0 = 0 ;
45577 char * kwnames[] = {
45578 (char *) "enable", NULL
45579 };
45580
45581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45582 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45583 if (!SWIG_IsOK(ecode1)) {
45584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45585 }
45586 arg1 = static_cast< bool >(val1);
45587 {
45588 PyThreadState* __tstate = wxPyBeginAllowThreads();
45589 wxMenuBar_SetAutoWindowMenu(arg1);
45590 wxPyEndAllowThreads(__tstate);
45591 if (PyErr_Occurred()) SWIG_fail;
45592 }
45593 resultobj = SWIG_Py_Void();
45594 return resultobj;
45595 fail:
45596 return NULL;
45597 }
45598
45599
45600 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45601 PyObject *resultobj = 0;
45602 bool result;
45603
45604 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45605 {
45606 PyThreadState* __tstate = wxPyBeginAllowThreads();
45607 result = (bool)wxMenuBar_GetAutoWindowMenu();
45608 wxPyEndAllowThreads(__tstate);
45609 if (PyErr_Occurred()) SWIG_fail;
45610 }
45611 {
45612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45613 }
45614 return resultobj;
45615 fail:
45616 return NULL;
45617 }
45618
45619
45620 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45621 PyObject *obj;
45622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45623 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45624 return SWIG_Py_Void();
45625 }
45626
45627 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45628 return SWIG_Python_InitShadowInstance(args);
45629 }
45630
45631 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45632 PyObject *resultobj = 0;
45633 wxMenu *arg1 = (wxMenu *) NULL ;
45634 int arg2 = (int) wxID_ANY ;
45635 wxString const &arg3_defvalue = wxPyEmptyString ;
45636 wxString *arg3 = (wxString *) &arg3_defvalue ;
45637 wxString const &arg4_defvalue = wxPyEmptyString ;
45638 wxString *arg4 = (wxString *) &arg4_defvalue ;
45639 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45640 wxMenu *arg6 = (wxMenu *) NULL ;
45641 wxMenuItem *result = 0 ;
45642 void *argp1 = 0 ;
45643 int res1 = 0 ;
45644 int val2 ;
45645 int ecode2 = 0 ;
45646 bool temp3 = false ;
45647 bool temp4 = false ;
45648 int val5 ;
45649 int ecode5 = 0 ;
45650 void *argp6 = 0 ;
45651 int res6 = 0 ;
45652 PyObject * obj0 = 0 ;
45653 PyObject * obj1 = 0 ;
45654 PyObject * obj2 = 0 ;
45655 PyObject * obj3 = 0 ;
45656 PyObject * obj4 = 0 ;
45657 PyObject * obj5 = 0 ;
45658 char * kwnames[] = {
45659 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45660 };
45661
45662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45663 if (obj0) {
45664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45665 if (!SWIG_IsOK(res1)) {
45666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45667 }
45668 arg1 = reinterpret_cast< wxMenu * >(argp1);
45669 }
45670 if (obj1) {
45671 ecode2 = SWIG_AsVal_int(obj1, &val2);
45672 if (!SWIG_IsOK(ecode2)) {
45673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45674 }
45675 arg2 = static_cast< int >(val2);
45676 }
45677 if (obj2) {
45678 {
45679 arg3 = wxString_in_helper(obj2);
45680 if (arg3 == NULL) SWIG_fail;
45681 temp3 = true;
45682 }
45683 }
45684 if (obj3) {
45685 {
45686 arg4 = wxString_in_helper(obj3);
45687 if (arg4 == NULL) SWIG_fail;
45688 temp4 = true;
45689 }
45690 }
45691 if (obj4) {
45692 ecode5 = SWIG_AsVal_int(obj4, &val5);
45693 if (!SWIG_IsOK(ecode5)) {
45694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45695 }
45696 arg5 = static_cast< wxItemKind >(val5);
45697 }
45698 if (obj5) {
45699 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45700 if (!SWIG_IsOK(res6)) {
45701 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45702 }
45703 arg6 = reinterpret_cast< wxMenu * >(argp6);
45704 }
45705 {
45706 PyThreadState* __tstate = wxPyBeginAllowThreads();
45707 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45708 wxPyEndAllowThreads(__tstate);
45709 if (PyErr_Occurred()) SWIG_fail;
45710 }
45711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45712 {
45713 if (temp3)
45714 delete arg3;
45715 }
45716 {
45717 if (temp4)
45718 delete arg4;
45719 }
45720 return resultobj;
45721 fail:
45722 {
45723 if (temp3)
45724 delete arg3;
45725 }
45726 {
45727 if (temp4)
45728 delete arg4;
45729 }
45730 return NULL;
45731 }
45732
45733
45734 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45735 PyObject *resultobj = 0;
45736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 PyObject *swig_obj[1] ;
45740
45741 if (!args) SWIG_fail;
45742 swig_obj[0] = args;
45743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45744 if (!SWIG_IsOK(res1)) {
45745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45746 }
45747 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45748 {
45749 PyThreadState* __tstate = wxPyBeginAllowThreads();
45750 delete arg1;
45751
45752 wxPyEndAllowThreads(__tstate);
45753 if (PyErr_Occurred()) SWIG_fail;
45754 }
45755 resultobj = SWIG_Py_Void();
45756 return resultobj;
45757 fail:
45758 return NULL;
45759 }
45760
45761
45762 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45763 PyObject *resultobj = 0;
45764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45765 wxMenu *result = 0 ;
45766 void *argp1 = 0 ;
45767 int res1 = 0 ;
45768 PyObject *swig_obj[1] ;
45769
45770 if (!args) SWIG_fail;
45771 swig_obj[0] = args;
45772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45773 if (!SWIG_IsOK(res1)) {
45774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45775 }
45776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 {
45784 resultobj = wxPyMake_wxObject(result, 0);
45785 }
45786 return resultobj;
45787 fail:
45788 return NULL;
45789 }
45790
45791
45792 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45793 PyObject *resultobj = 0;
45794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45795 wxMenu *arg2 = (wxMenu *) 0 ;
45796 void *argp1 = 0 ;
45797 int res1 = 0 ;
45798 void *argp2 = 0 ;
45799 int res2 = 0 ;
45800 PyObject * obj0 = 0 ;
45801 PyObject * obj1 = 0 ;
45802 char * kwnames[] = {
45803 (char *) "self",(char *) "menu", NULL
45804 };
45805
45806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45808 if (!SWIG_IsOK(res1)) {
45809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45810 }
45811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45813 if (!SWIG_IsOK(res2)) {
45814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45815 }
45816 arg2 = reinterpret_cast< wxMenu * >(argp2);
45817 {
45818 PyThreadState* __tstate = wxPyBeginAllowThreads();
45819 (arg1)->SetMenu(arg2);
45820 wxPyEndAllowThreads(__tstate);
45821 if (PyErr_Occurred()) SWIG_fail;
45822 }
45823 resultobj = SWIG_Py_Void();
45824 return resultobj;
45825 fail:
45826 return NULL;
45827 }
45828
45829
45830 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45831 PyObject *resultobj = 0;
45832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45833 int arg2 ;
45834 void *argp1 = 0 ;
45835 int res1 = 0 ;
45836 int val2 ;
45837 int ecode2 = 0 ;
45838 PyObject * obj0 = 0 ;
45839 PyObject * obj1 = 0 ;
45840 char * kwnames[] = {
45841 (char *) "self",(char *) "id", NULL
45842 };
45843
45844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45846 if (!SWIG_IsOK(res1)) {
45847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45848 }
45849 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45850 ecode2 = SWIG_AsVal_int(obj1, &val2);
45851 if (!SWIG_IsOK(ecode2)) {
45852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45853 }
45854 arg2 = static_cast< int >(val2);
45855 {
45856 PyThreadState* __tstate = wxPyBeginAllowThreads();
45857 (arg1)->SetId(arg2);
45858 wxPyEndAllowThreads(__tstate);
45859 if (PyErr_Occurred()) SWIG_fail;
45860 }
45861 resultobj = SWIG_Py_Void();
45862 return resultobj;
45863 fail:
45864 return NULL;
45865 }
45866
45867
45868 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45869 PyObject *resultobj = 0;
45870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45871 int result;
45872 void *argp1 = 0 ;
45873 int res1 = 0 ;
45874 PyObject *swig_obj[1] ;
45875
45876 if (!args) SWIG_fail;
45877 swig_obj[0] = args;
45878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45881 }
45882 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 result = (int)((wxMenuItem const *)arg1)->GetId();
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 resultobj = SWIG_From_int(static_cast< int >(result));
45890 return resultobj;
45891 fail:
45892 return NULL;
45893 }
45894
45895
45896 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45897 PyObject *resultobj = 0;
45898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45899 bool result;
45900 void *argp1 = 0 ;
45901 int res1 = 0 ;
45902 PyObject *swig_obj[1] ;
45903
45904 if (!args) SWIG_fail;
45905 swig_obj[0] = args;
45906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45907 if (!SWIG_IsOK(res1)) {
45908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45909 }
45910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45911 {
45912 PyThreadState* __tstate = wxPyBeginAllowThreads();
45913 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 {
45918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45919 }
45920 return resultobj;
45921 fail:
45922 return NULL;
45923 }
45924
45925
45926 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45927 PyObject *resultobj = 0;
45928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45929 wxString *arg2 = 0 ;
45930 void *argp1 = 0 ;
45931 int res1 = 0 ;
45932 bool temp2 = false ;
45933 PyObject * obj0 = 0 ;
45934 PyObject * obj1 = 0 ;
45935 char * kwnames[] = {
45936 (char *) "self",(char *) "str", NULL
45937 };
45938
45939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45941 if (!SWIG_IsOK(res1)) {
45942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45943 }
45944 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45945 {
45946 arg2 = wxString_in_helper(obj1);
45947 if (arg2 == NULL) SWIG_fail;
45948 temp2 = true;
45949 }
45950 {
45951 PyThreadState* __tstate = wxPyBeginAllowThreads();
45952 (arg1)->SetText((wxString const &)*arg2);
45953 wxPyEndAllowThreads(__tstate);
45954 if (PyErr_Occurred()) SWIG_fail;
45955 }
45956 resultobj = SWIG_Py_Void();
45957 {
45958 if (temp2)
45959 delete arg2;
45960 }
45961 return resultobj;
45962 fail:
45963 {
45964 if (temp2)
45965 delete arg2;
45966 }
45967 return NULL;
45968 }
45969
45970
45971 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45972 PyObject *resultobj = 0;
45973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45974 wxString result;
45975 void *argp1 = 0 ;
45976 int res1 = 0 ;
45977 PyObject *swig_obj[1] ;
45978
45979 if (!args) SWIG_fail;
45980 swig_obj[0] = args;
45981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45982 if (!SWIG_IsOK(res1)) {
45983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45984 }
45985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45986 {
45987 PyThreadState* __tstate = wxPyBeginAllowThreads();
45988 result = ((wxMenuItem const *)arg1)->GetLabel();
45989 wxPyEndAllowThreads(__tstate);
45990 if (PyErr_Occurred()) SWIG_fail;
45991 }
45992 {
45993 #if wxUSE_UNICODE
45994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45995 #else
45996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45997 #endif
45998 }
45999 return resultobj;
46000 fail:
46001 return NULL;
46002 }
46003
46004
46005 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46006 PyObject *resultobj = 0;
46007 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46008 wxString *result = 0 ;
46009 void *argp1 = 0 ;
46010 int res1 = 0 ;
46011 PyObject *swig_obj[1] ;
46012
46013 if (!args) SWIG_fail;
46014 swig_obj[0] = args;
46015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46016 if (!SWIG_IsOK(res1)) {
46017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46018 }
46019 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46020 {
46021 PyThreadState* __tstate = wxPyBeginAllowThreads();
46022 {
46023 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46024 result = (wxString *) &_result_ref;
46025 }
46026 wxPyEndAllowThreads(__tstate);
46027 if (PyErr_Occurred()) SWIG_fail;
46028 }
46029 {
46030 #if wxUSE_UNICODE
46031 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46032 #else
46033 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46034 #endif
46035 }
46036 return resultobj;
46037 fail:
46038 return NULL;
46039 }
46040
46041
46042 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46043 PyObject *resultobj = 0;
46044 wxString *arg1 = 0 ;
46045 wxString result;
46046 bool temp1 = false ;
46047 PyObject * obj0 = 0 ;
46048 char * kwnames[] = {
46049 (char *) "text", NULL
46050 };
46051
46052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46053 {
46054 arg1 = wxString_in_helper(obj0);
46055 if (arg1 == NULL) SWIG_fail;
46056 temp1 = true;
46057 }
46058 {
46059 PyThreadState* __tstate = wxPyBeginAllowThreads();
46060 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46061 wxPyEndAllowThreads(__tstate);
46062 if (PyErr_Occurred()) SWIG_fail;
46063 }
46064 {
46065 #if wxUSE_UNICODE
46066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46067 #else
46068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46069 #endif
46070 }
46071 {
46072 if (temp1)
46073 delete arg1;
46074 }
46075 return resultobj;
46076 fail:
46077 {
46078 if (temp1)
46079 delete arg1;
46080 }
46081 return NULL;
46082 }
46083
46084
46085 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46086 PyObject *resultobj = 0;
46087 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46088 wxItemKind result;
46089 void *argp1 = 0 ;
46090 int res1 = 0 ;
46091 PyObject *swig_obj[1] ;
46092
46093 if (!args) SWIG_fail;
46094 swig_obj[0] = args;
46095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46096 if (!SWIG_IsOK(res1)) {
46097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46098 }
46099 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46100 {
46101 PyThreadState* __tstate = wxPyBeginAllowThreads();
46102 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46103 wxPyEndAllowThreads(__tstate);
46104 if (PyErr_Occurred()) SWIG_fail;
46105 }
46106 resultobj = SWIG_From_int(static_cast< int >(result));
46107 return resultobj;
46108 fail:
46109 return NULL;
46110 }
46111
46112
46113 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46114 PyObject *resultobj = 0;
46115 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46116 wxItemKind arg2 ;
46117 void *argp1 = 0 ;
46118 int res1 = 0 ;
46119 int val2 ;
46120 int ecode2 = 0 ;
46121 PyObject * obj0 = 0 ;
46122 PyObject * obj1 = 0 ;
46123 char * kwnames[] = {
46124 (char *) "self",(char *) "kind", NULL
46125 };
46126
46127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46129 if (!SWIG_IsOK(res1)) {
46130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46131 }
46132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46133 ecode2 = SWIG_AsVal_int(obj1, &val2);
46134 if (!SWIG_IsOK(ecode2)) {
46135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46136 }
46137 arg2 = static_cast< wxItemKind >(val2);
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 (arg1)->SetKind(arg2);
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 resultobj = SWIG_Py_Void();
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46154 bool arg2 ;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 bool val2 ;
46158 int ecode2 = 0 ;
46159 PyObject * obj0 = 0 ;
46160 PyObject * obj1 = 0 ;
46161 char * kwnames[] = {
46162 (char *) "self",(char *) "checkable", NULL
46163 };
46164
46165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46167 if (!SWIG_IsOK(res1)) {
46168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46169 }
46170 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46172 if (!SWIG_IsOK(ecode2)) {
46173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46174 }
46175 arg2 = static_cast< bool >(val2);
46176 {
46177 PyThreadState* __tstate = wxPyBeginAllowThreads();
46178 (arg1)->SetCheckable(arg2);
46179 wxPyEndAllowThreads(__tstate);
46180 if (PyErr_Occurred()) SWIG_fail;
46181 }
46182 resultobj = SWIG_Py_Void();
46183 return resultobj;
46184 fail:
46185 return NULL;
46186 }
46187
46188
46189 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46190 PyObject *resultobj = 0;
46191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46192 bool result;
46193 void *argp1 = 0 ;
46194 int res1 = 0 ;
46195 PyObject *swig_obj[1] ;
46196
46197 if (!args) SWIG_fail;
46198 swig_obj[0] = args;
46199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46200 if (!SWIG_IsOK(res1)) {
46201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46202 }
46203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46204 {
46205 PyThreadState* __tstate = wxPyBeginAllowThreads();
46206 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46207 wxPyEndAllowThreads(__tstate);
46208 if (PyErr_Occurred()) SWIG_fail;
46209 }
46210 {
46211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46212 }
46213 return resultobj;
46214 fail:
46215 return NULL;
46216 }
46217
46218
46219 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46220 PyObject *resultobj = 0;
46221 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46222 bool result;
46223 void *argp1 = 0 ;
46224 int res1 = 0 ;
46225 PyObject *swig_obj[1] ;
46226
46227 if (!args) SWIG_fail;
46228 swig_obj[0] = args;
46229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46232 }
46233 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 {
46241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46242 }
46243 return resultobj;
46244 fail:
46245 return NULL;
46246 }
46247
46248
46249 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46250 PyObject *resultobj = 0;
46251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46252 wxMenu *arg2 = (wxMenu *) 0 ;
46253 void *argp1 = 0 ;
46254 int res1 = 0 ;
46255 void *argp2 = 0 ;
46256 int res2 = 0 ;
46257 PyObject * obj0 = 0 ;
46258 PyObject * obj1 = 0 ;
46259 char * kwnames[] = {
46260 (char *) "self",(char *) "menu", NULL
46261 };
46262
46263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46265 if (!SWIG_IsOK(res1)) {
46266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46267 }
46268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46270 if (!SWIG_IsOK(res2)) {
46271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46272 }
46273 arg2 = reinterpret_cast< wxMenu * >(argp2);
46274 {
46275 PyThreadState* __tstate = wxPyBeginAllowThreads();
46276 (arg1)->SetSubMenu(arg2);
46277 wxPyEndAllowThreads(__tstate);
46278 if (PyErr_Occurred()) SWIG_fail;
46279 }
46280 resultobj = SWIG_Py_Void();
46281 return resultobj;
46282 fail:
46283 return NULL;
46284 }
46285
46286
46287 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46288 PyObject *resultobj = 0;
46289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46290 wxMenu *result = 0 ;
46291 void *argp1 = 0 ;
46292 int res1 = 0 ;
46293 PyObject *swig_obj[1] ;
46294
46295 if (!args) SWIG_fail;
46296 swig_obj[0] = args;
46297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46298 if (!SWIG_IsOK(res1)) {
46299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46300 }
46301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46302 {
46303 PyThreadState* __tstate = wxPyBeginAllowThreads();
46304 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46305 wxPyEndAllowThreads(__tstate);
46306 if (PyErr_Occurred()) SWIG_fail;
46307 }
46308 {
46309 resultobj = wxPyMake_wxObject(result, 0);
46310 }
46311 return resultobj;
46312 fail:
46313 return NULL;
46314 }
46315
46316
46317 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46318 PyObject *resultobj = 0;
46319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46320 bool arg2 = (bool) true ;
46321 void *argp1 = 0 ;
46322 int res1 = 0 ;
46323 bool val2 ;
46324 int ecode2 = 0 ;
46325 PyObject * obj0 = 0 ;
46326 PyObject * obj1 = 0 ;
46327 char * kwnames[] = {
46328 (char *) "self",(char *) "enable", NULL
46329 };
46330
46331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46333 if (!SWIG_IsOK(res1)) {
46334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46335 }
46336 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46337 if (obj1) {
46338 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46339 if (!SWIG_IsOK(ecode2)) {
46340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46341 }
46342 arg2 = static_cast< bool >(val2);
46343 }
46344 {
46345 PyThreadState* __tstate = wxPyBeginAllowThreads();
46346 (arg1)->Enable(arg2);
46347 wxPyEndAllowThreads(__tstate);
46348 if (PyErr_Occurred()) SWIG_fail;
46349 }
46350 resultobj = SWIG_Py_Void();
46351 return resultobj;
46352 fail:
46353 return NULL;
46354 }
46355
46356
46357 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46358 PyObject *resultobj = 0;
46359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46360 bool result;
46361 void *argp1 = 0 ;
46362 int res1 = 0 ;
46363 PyObject *swig_obj[1] ;
46364
46365 if (!args) SWIG_fail;
46366 swig_obj[0] = args;
46367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46368 if (!SWIG_IsOK(res1)) {
46369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46370 }
46371 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46372 {
46373 PyThreadState* __tstate = wxPyBeginAllowThreads();
46374 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46375 wxPyEndAllowThreads(__tstate);
46376 if (PyErr_Occurred()) SWIG_fail;
46377 }
46378 {
46379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46380 }
46381 return resultobj;
46382 fail:
46383 return NULL;
46384 }
46385
46386
46387 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46388 PyObject *resultobj = 0;
46389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46390 bool arg2 = (bool) true ;
46391 void *argp1 = 0 ;
46392 int res1 = 0 ;
46393 bool val2 ;
46394 int ecode2 = 0 ;
46395 PyObject * obj0 = 0 ;
46396 PyObject * obj1 = 0 ;
46397 char * kwnames[] = {
46398 (char *) "self",(char *) "check", NULL
46399 };
46400
46401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46403 if (!SWIG_IsOK(res1)) {
46404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46405 }
46406 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46407 if (obj1) {
46408 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46409 if (!SWIG_IsOK(ecode2)) {
46410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46411 }
46412 arg2 = static_cast< bool >(val2);
46413 }
46414 {
46415 PyThreadState* __tstate = wxPyBeginAllowThreads();
46416 (arg1)->Check(arg2);
46417 wxPyEndAllowThreads(__tstate);
46418 if (PyErr_Occurred()) SWIG_fail;
46419 }
46420 resultobj = SWIG_Py_Void();
46421 return resultobj;
46422 fail:
46423 return NULL;
46424 }
46425
46426
46427 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46428 PyObject *resultobj = 0;
46429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46430 bool result;
46431 void *argp1 = 0 ;
46432 int res1 = 0 ;
46433 PyObject *swig_obj[1] ;
46434
46435 if (!args) SWIG_fail;
46436 swig_obj[0] = args;
46437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46438 if (!SWIG_IsOK(res1)) {
46439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46440 }
46441 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 {
46449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46450 }
46451 return resultobj;
46452 fail:
46453 return NULL;
46454 }
46455
46456
46457 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46458 PyObject *resultobj = 0;
46459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46460 void *argp1 = 0 ;
46461 int res1 = 0 ;
46462 PyObject *swig_obj[1] ;
46463
46464 if (!args) SWIG_fail;
46465 swig_obj[0] = args;
46466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46467 if (!SWIG_IsOK(res1)) {
46468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46469 }
46470 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46471 {
46472 PyThreadState* __tstate = wxPyBeginAllowThreads();
46473 (arg1)->Toggle();
46474 wxPyEndAllowThreads(__tstate);
46475 if (PyErr_Occurred()) SWIG_fail;
46476 }
46477 resultobj = SWIG_Py_Void();
46478 return resultobj;
46479 fail:
46480 return NULL;
46481 }
46482
46483
46484 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46485 PyObject *resultobj = 0;
46486 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46487 wxString *arg2 = 0 ;
46488 void *argp1 = 0 ;
46489 int res1 = 0 ;
46490 bool temp2 = false ;
46491 PyObject * obj0 = 0 ;
46492 PyObject * obj1 = 0 ;
46493 char * kwnames[] = {
46494 (char *) "self",(char *) "str", NULL
46495 };
46496
46497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46499 if (!SWIG_IsOK(res1)) {
46500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46501 }
46502 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46503 {
46504 arg2 = wxString_in_helper(obj1);
46505 if (arg2 == NULL) SWIG_fail;
46506 temp2 = true;
46507 }
46508 {
46509 PyThreadState* __tstate = wxPyBeginAllowThreads();
46510 (arg1)->SetHelp((wxString const &)*arg2);
46511 wxPyEndAllowThreads(__tstate);
46512 if (PyErr_Occurred()) SWIG_fail;
46513 }
46514 resultobj = SWIG_Py_Void();
46515 {
46516 if (temp2)
46517 delete arg2;
46518 }
46519 return resultobj;
46520 fail:
46521 {
46522 if (temp2)
46523 delete arg2;
46524 }
46525 return NULL;
46526 }
46527
46528
46529 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46530 PyObject *resultobj = 0;
46531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46532 wxString *result = 0 ;
46533 void *argp1 = 0 ;
46534 int res1 = 0 ;
46535 PyObject *swig_obj[1] ;
46536
46537 if (!args) SWIG_fail;
46538 swig_obj[0] = args;
46539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46540 if (!SWIG_IsOK(res1)) {
46541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46542 }
46543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46544 {
46545 PyThreadState* __tstate = wxPyBeginAllowThreads();
46546 {
46547 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46548 result = (wxString *) &_result_ref;
46549 }
46550 wxPyEndAllowThreads(__tstate);
46551 if (PyErr_Occurred()) SWIG_fail;
46552 }
46553 {
46554 #if wxUSE_UNICODE
46555 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46556 #else
46557 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46558 #endif
46559 }
46560 return resultobj;
46561 fail:
46562 return NULL;
46563 }
46564
46565
46566 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46567 PyObject *resultobj = 0;
46568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46569 wxAcceleratorEntry *result = 0 ;
46570 void *argp1 = 0 ;
46571 int res1 = 0 ;
46572 PyObject *swig_obj[1] ;
46573
46574 if (!args) SWIG_fail;
46575 swig_obj[0] = args;
46576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46577 if (!SWIG_IsOK(res1)) {
46578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46579 }
46580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46581 {
46582 PyThreadState* __tstate = wxPyBeginAllowThreads();
46583 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46584 wxPyEndAllowThreads(__tstate);
46585 if (PyErr_Occurred()) SWIG_fail;
46586 }
46587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46588 return resultobj;
46589 fail:
46590 return NULL;
46591 }
46592
46593
46594 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46595 PyObject *resultobj = 0;
46596 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46597 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46598 void *argp1 = 0 ;
46599 int res1 = 0 ;
46600 void *argp2 = 0 ;
46601 int res2 = 0 ;
46602 PyObject * obj0 = 0 ;
46603 PyObject * obj1 = 0 ;
46604 char * kwnames[] = {
46605 (char *) "self",(char *) "accel", NULL
46606 };
46607
46608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46610 if (!SWIG_IsOK(res1)) {
46611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46612 }
46613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46615 if (!SWIG_IsOK(res2)) {
46616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46617 }
46618 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46619 {
46620 PyThreadState* __tstate = wxPyBeginAllowThreads();
46621 (arg1)->SetAccel(arg2);
46622 wxPyEndAllowThreads(__tstate);
46623 if (PyErr_Occurred()) SWIG_fail;
46624 }
46625 resultobj = SWIG_Py_Void();
46626 return resultobj;
46627 fail:
46628 return NULL;
46629 }
46630
46631
46632 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46633 PyObject *resultobj = 0;
46634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46635 wxBitmap *arg2 = 0 ;
46636 void *argp1 = 0 ;
46637 int res1 = 0 ;
46638 void *argp2 = 0 ;
46639 int res2 = 0 ;
46640 PyObject * obj0 = 0 ;
46641 PyObject * obj1 = 0 ;
46642 char * kwnames[] = {
46643 (char *) "self",(char *) "bitmap", NULL
46644 };
46645
46646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46648 if (!SWIG_IsOK(res1)) {
46649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46650 }
46651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46653 if (!SWIG_IsOK(res2)) {
46654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46655 }
46656 if (!argp2) {
46657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46658 }
46659 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 resultobj = SWIG_Py_Void();
46667 return resultobj;
46668 fail:
46669 return NULL;
46670 }
46671
46672
46673 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46674 PyObject *resultobj = 0;
46675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46676 wxBitmap *result = 0 ;
46677 void *argp1 = 0 ;
46678 int res1 = 0 ;
46679 PyObject *swig_obj[1] ;
46680
46681 if (!args) SWIG_fail;
46682 swig_obj[0] = args;
46683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46686 }
46687 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46688 {
46689 PyThreadState* __tstate = wxPyBeginAllowThreads();
46690 {
46691 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46692 result = (wxBitmap *) &_result_ref;
46693 }
46694 wxPyEndAllowThreads(__tstate);
46695 if (PyErr_Occurred()) SWIG_fail;
46696 }
46697 {
46698 wxBitmap* resultptr = new wxBitmap(*result);
46699 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46700 }
46701 return resultobj;
46702 fail:
46703 return NULL;
46704 }
46705
46706
46707 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46708 PyObject *resultobj = 0;
46709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46710 wxFont *arg2 = 0 ;
46711 void *argp1 = 0 ;
46712 int res1 = 0 ;
46713 void *argp2 = 0 ;
46714 int res2 = 0 ;
46715 PyObject * obj0 = 0 ;
46716 PyObject * obj1 = 0 ;
46717 char * kwnames[] = {
46718 (char *) "self",(char *) "font", NULL
46719 };
46720
46721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46723 if (!SWIG_IsOK(res1)) {
46724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46725 }
46726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46727 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46728 if (!SWIG_IsOK(res2)) {
46729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46730 }
46731 if (!argp2) {
46732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46733 }
46734 arg2 = reinterpret_cast< wxFont * >(argp2);
46735 {
46736 PyThreadState* __tstate = wxPyBeginAllowThreads();
46737 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46738 wxPyEndAllowThreads(__tstate);
46739 if (PyErr_Occurred()) SWIG_fail;
46740 }
46741 resultobj = SWIG_Py_Void();
46742 return resultobj;
46743 fail:
46744 return NULL;
46745 }
46746
46747
46748 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46749 PyObject *resultobj = 0;
46750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46751 wxFont result;
46752 void *argp1 = 0 ;
46753 int res1 = 0 ;
46754 PyObject *swig_obj[1] ;
46755
46756 if (!args) SWIG_fail;
46757 swig_obj[0] = args;
46758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46759 if (!SWIG_IsOK(res1)) {
46760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46761 }
46762 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46763 {
46764 PyThreadState* __tstate = wxPyBeginAllowThreads();
46765 result = wxMenuItem_GetFont(arg1);
46766 wxPyEndAllowThreads(__tstate);
46767 if (PyErr_Occurred()) SWIG_fail;
46768 }
46769 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46770 return resultobj;
46771 fail:
46772 return NULL;
46773 }
46774
46775
46776 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46777 PyObject *resultobj = 0;
46778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46779 wxColour *arg2 = 0 ;
46780 void *argp1 = 0 ;
46781 int res1 = 0 ;
46782 wxColour temp2 ;
46783 PyObject * obj0 = 0 ;
46784 PyObject * obj1 = 0 ;
46785 char * kwnames[] = {
46786 (char *) "self",(char *) "colText", NULL
46787 };
46788
46789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46791 if (!SWIG_IsOK(res1)) {
46792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46793 }
46794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46795 {
46796 arg2 = &temp2;
46797 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46798 }
46799 {
46800 PyThreadState* __tstate = wxPyBeginAllowThreads();
46801 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46802 wxPyEndAllowThreads(__tstate);
46803 if (PyErr_Occurred()) SWIG_fail;
46804 }
46805 resultobj = SWIG_Py_Void();
46806 return resultobj;
46807 fail:
46808 return NULL;
46809 }
46810
46811
46812 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46813 PyObject *resultobj = 0;
46814 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46815 wxColour result;
46816 void *argp1 = 0 ;
46817 int res1 = 0 ;
46818 PyObject *swig_obj[1] ;
46819
46820 if (!args) SWIG_fail;
46821 swig_obj[0] = args;
46822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46823 if (!SWIG_IsOK(res1)) {
46824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46825 }
46826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46827 {
46828 PyThreadState* __tstate = wxPyBeginAllowThreads();
46829 result = wxMenuItem_GetTextColour(arg1);
46830 wxPyEndAllowThreads(__tstate);
46831 if (PyErr_Occurred()) SWIG_fail;
46832 }
46833 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46834 return resultobj;
46835 fail:
46836 return NULL;
46837 }
46838
46839
46840 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46841 PyObject *resultobj = 0;
46842 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46843 wxColour *arg2 = 0 ;
46844 void *argp1 = 0 ;
46845 int res1 = 0 ;
46846 wxColour temp2 ;
46847 PyObject * obj0 = 0 ;
46848 PyObject * obj1 = 0 ;
46849 char * kwnames[] = {
46850 (char *) "self",(char *) "colBack", NULL
46851 };
46852
46853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46855 if (!SWIG_IsOK(res1)) {
46856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46857 }
46858 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46859 {
46860 arg2 = &temp2;
46861 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46862 }
46863 {
46864 PyThreadState* __tstate = wxPyBeginAllowThreads();
46865 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46866 wxPyEndAllowThreads(__tstate);
46867 if (PyErr_Occurred()) SWIG_fail;
46868 }
46869 resultobj = SWIG_Py_Void();
46870 return resultobj;
46871 fail:
46872 return NULL;
46873 }
46874
46875
46876 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46877 PyObject *resultobj = 0;
46878 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46879 wxColour result;
46880 void *argp1 = 0 ;
46881 int res1 = 0 ;
46882 PyObject *swig_obj[1] ;
46883
46884 if (!args) SWIG_fail;
46885 swig_obj[0] = args;
46886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46887 if (!SWIG_IsOK(res1)) {
46888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46889 }
46890 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46891 {
46892 PyThreadState* __tstate = wxPyBeginAllowThreads();
46893 result = wxMenuItem_GetBackgroundColour(arg1);
46894 wxPyEndAllowThreads(__tstate);
46895 if (PyErr_Occurred()) SWIG_fail;
46896 }
46897 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46898 return resultobj;
46899 fail:
46900 return NULL;
46901 }
46902
46903
46904 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46905 PyObject *resultobj = 0;
46906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46907 wxBitmap *arg2 = 0 ;
46908 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46909 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46910 void *argp1 = 0 ;
46911 int res1 = 0 ;
46912 void *argp2 = 0 ;
46913 int res2 = 0 ;
46914 void *argp3 = 0 ;
46915 int res3 = 0 ;
46916 PyObject * obj0 = 0 ;
46917 PyObject * obj1 = 0 ;
46918 PyObject * obj2 = 0 ;
46919 char * kwnames[] = {
46920 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46921 };
46922
46923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46925 if (!SWIG_IsOK(res1)) {
46926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46927 }
46928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46930 if (!SWIG_IsOK(res2)) {
46931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46932 }
46933 if (!argp2) {
46934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46935 }
46936 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46937 if (obj2) {
46938 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46939 if (!SWIG_IsOK(res3)) {
46940 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46941 }
46942 if (!argp3) {
46943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46944 }
46945 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46946 }
46947 {
46948 PyThreadState* __tstate = wxPyBeginAllowThreads();
46949 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46950 wxPyEndAllowThreads(__tstate);
46951 if (PyErr_Occurred()) SWIG_fail;
46952 }
46953 resultobj = SWIG_Py_Void();
46954 return resultobj;
46955 fail:
46956 return NULL;
46957 }
46958
46959
46960 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46961 PyObject *resultobj = 0;
46962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46963 wxBitmap *arg2 = 0 ;
46964 void *argp1 = 0 ;
46965 int res1 = 0 ;
46966 void *argp2 = 0 ;
46967 int res2 = 0 ;
46968 PyObject * obj0 = 0 ;
46969 PyObject * obj1 = 0 ;
46970 char * kwnames[] = {
46971 (char *) "self",(char *) "bmpDisabled", NULL
46972 };
46973
46974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46976 if (!SWIG_IsOK(res1)) {
46977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46978 }
46979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46980 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46981 if (!SWIG_IsOK(res2)) {
46982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46983 }
46984 if (!argp2) {
46985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46986 }
46987 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46988 {
46989 PyThreadState* __tstate = wxPyBeginAllowThreads();
46990 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46991 wxPyEndAllowThreads(__tstate);
46992 if (PyErr_Occurred()) SWIG_fail;
46993 }
46994 resultobj = SWIG_Py_Void();
46995 return resultobj;
46996 fail:
46997 return NULL;
46998 }
46999
47000
47001 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47002 PyObject *resultobj = 0;
47003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47004 wxBitmap *result = 0 ;
47005 void *argp1 = 0 ;
47006 int res1 = 0 ;
47007 PyObject *swig_obj[1] ;
47008
47009 if (!args) SWIG_fail;
47010 swig_obj[0] = args;
47011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47012 if (!SWIG_IsOK(res1)) {
47013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47014 }
47015 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47016 {
47017 PyThreadState* __tstate = wxPyBeginAllowThreads();
47018 {
47019 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47020 result = (wxBitmap *) &_result_ref;
47021 }
47022 wxPyEndAllowThreads(__tstate);
47023 if (PyErr_Occurred()) SWIG_fail;
47024 }
47025 {
47026 wxBitmap* resultptr = new wxBitmap(*result);
47027 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47028 }
47029 return resultobj;
47030 fail:
47031 return NULL;
47032 }
47033
47034
47035 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47036 PyObject *resultobj = 0;
47037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47038 int arg2 ;
47039 void *argp1 = 0 ;
47040 int res1 = 0 ;
47041 int val2 ;
47042 int ecode2 = 0 ;
47043 PyObject * obj0 = 0 ;
47044 PyObject * obj1 = 0 ;
47045 char * kwnames[] = {
47046 (char *) "self",(char *) "nWidth", NULL
47047 };
47048
47049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47051 if (!SWIG_IsOK(res1)) {
47052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47053 }
47054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47055 ecode2 = SWIG_AsVal_int(obj1, &val2);
47056 if (!SWIG_IsOK(ecode2)) {
47057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47058 }
47059 arg2 = static_cast< int >(val2);
47060 {
47061 PyThreadState* __tstate = wxPyBeginAllowThreads();
47062 wxMenuItem_SetMarginWidth(arg1,arg2);
47063 wxPyEndAllowThreads(__tstate);
47064 if (PyErr_Occurred()) SWIG_fail;
47065 }
47066 resultobj = SWIG_Py_Void();
47067 return resultobj;
47068 fail:
47069 return NULL;
47070 }
47071
47072
47073 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47074 PyObject *resultobj = 0;
47075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47076 int result;
47077 void *argp1 = 0 ;
47078 int res1 = 0 ;
47079 PyObject *swig_obj[1] ;
47080
47081 if (!args) SWIG_fail;
47082 swig_obj[0] = args;
47083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47084 if (!SWIG_IsOK(res1)) {
47085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47086 }
47087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47088 {
47089 PyThreadState* __tstate = wxPyBeginAllowThreads();
47090 result = (int)wxMenuItem_GetMarginWidth(arg1);
47091 wxPyEndAllowThreads(__tstate);
47092 if (PyErr_Occurred()) SWIG_fail;
47093 }
47094 resultobj = SWIG_From_int(static_cast< int >(result));
47095 return resultobj;
47096 fail:
47097 return NULL;
47098 }
47099
47100
47101 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47102 PyObject *resultobj = 0;
47103 int result;
47104
47105 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 result = (int)wxMenuItem_GetDefaultMarginWidth();
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_From_int(static_cast< int >(result));
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47120 PyObject *resultobj = 0;
47121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47122 bool result;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 PyObject *swig_obj[1] ;
47126
47127 if (!args) SWIG_fail;
47128 swig_obj[0] = args;
47129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47130 if (!SWIG_IsOK(res1)) {
47131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47132 }
47133 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 {
47141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47142 }
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47152 bool arg2 = (bool) true ;
47153 void *argp1 = 0 ;
47154 int res1 = 0 ;
47155 bool val2 ;
47156 int ecode2 = 0 ;
47157 PyObject * obj0 = 0 ;
47158 PyObject * obj1 = 0 ;
47159 char * kwnames[] = {
47160 (char *) "self",(char *) "ownerDrawn", NULL
47161 };
47162
47163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47165 if (!SWIG_IsOK(res1)) {
47166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47167 }
47168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47169 if (obj1) {
47170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47171 if (!SWIG_IsOK(ecode2)) {
47172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47173 }
47174 arg2 = static_cast< bool >(val2);
47175 }
47176 {
47177 PyThreadState* __tstate = wxPyBeginAllowThreads();
47178 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47179 wxPyEndAllowThreads(__tstate);
47180 if (PyErr_Occurred()) SWIG_fail;
47181 }
47182 resultobj = SWIG_Py_Void();
47183 return resultobj;
47184 fail:
47185 return NULL;
47186 }
47187
47188
47189 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47190 PyObject *resultobj = 0;
47191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47192 void *argp1 = 0 ;
47193 int res1 = 0 ;
47194 PyObject *swig_obj[1] ;
47195
47196 if (!args) SWIG_fail;
47197 swig_obj[0] = args;
47198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47199 if (!SWIG_IsOK(res1)) {
47200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47201 }
47202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47203 {
47204 PyThreadState* __tstate = wxPyBeginAllowThreads();
47205 wxMenuItem_ResetOwnerDrawn(arg1);
47206 wxPyEndAllowThreads(__tstate);
47207 if (PyErr_Occurred()) SWIG_fail;
47208 }
47209 resultobj = SWIG_Py_Void();
47210 return resultobj;
47211 fail:
47212 return NULL;
47213 }
47214
47215
47216 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47217 PyObject *obj;
47218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47219 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47220 return SWIG_Py_Void();
47221 }
47222
47223 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47224 return SWIG_Python_InitShadowInstance(args);
47225 }
47226
47227 SWIGINTERN int ControlNameStr_set(PyObject *) {
47228 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47229 return 1;
47230 }
47231
47232
47233 SWIGINTERN PyObject *ControlNameStr_get(void) {
47234 PyObject *pyobj = 0;
47235
47236 {
47237 #if wxUSE_UNICODE
47238 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47239 #else
47240 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47241 #endif
47242 }
47243 return pyobj;
47244 }
47245
47246
47247 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47248 PyObject *resultobj = 0;
47249 wxWindow *arg1 = (wxWindow *) 0 ;
47250 int arg2 = (int) -1 ;
47251 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47252 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47253 wxSize const &arg4_defvalue = wxDefaultSize ;
47254 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47255 long arg5 = (long) 0 ;
47256 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47257 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47258 wxString const &arg7_defvalue = wxPyControlNameStr ;
47259 wxString *arg7 = (wxString *) &arg7_defvalue ;
47260 wxControl *result = 0 ;
47261 void *argp1 = 0 ;
47262 int res1 = 0 ;
47263 int val2 ;
47264 int ecode2 = 0 ;
47265 wxPoint temp3 ;
47266 wxSize temp4 ;
47267 long val5 ;
47268 int ecode5 = 0 ;
47269 void *argp6 = 0 ;
47270 int res6 = 0 ;
47271 bool temp7 = false ;
47272 PyObject * obj0 = 0 ;
47273 PyObject * obj1 = 0 ;
47274 PyObject * obj2 = 0 ;
47275 PyObject * obj3 = 0 ;
47276 PyObject * obj4 = 0 ;
47277 PyObject * obj5 = 0 ;
47278 PyObject * obj6 = 0 ;
47279 char * kwnames[] = {
47280 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47281 };
47282
47283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47285 if (!SWIG_IsOK(res1)) {
47286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47287 }
47288 arg1 = reinterpret_cast< wxWindow * >(argp1);
47289 if (obj1) {
47290 ecode2 = SWIG_AsVal_int(obj1, &val2);
47291 if (!SWIG_IsOK(ecode2)) {
47292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47293 }
47294 arg2 = static_cast< int >(val2);
47295 }
47296 if (obj2) {
47297 {
47298 arg3 = &temp3;
47299 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47300 }
47301 }
47302 if (obj3) {
47303 {
47304 arg4 = &temp4;
47305 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47306 }
47307 }
47308 if (obj4) {
47309 ecode5 = SWIG_AsVal_long(obj4, &val5);
47310 if (!SWIG_IsOK(ecode5)) {
47311 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47312 }
47313 arg5 = static_cast< long >(val5);
47314 }
47315 if (obj5) {
47316 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47317 if (!SWIG_IsOK(res6)) {
47318 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47319 }
47320 if (!argp6) {
47321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47322 }
47323 arg6 = reinterpret_cast< wxValidator * >(argp6);
47324 }
47325 if (obj6) {
47326 {
47327 arg7 = wxString_in_helper(obj6);
47328 if (arg7 == NULL) SWIG_fail;
47329 temp7 = true;
47330 }
47331 }
47332 {
47333 if (!wxPyCheckForApp()) SWIG_fail;
47334 PyThreadState* __tstate = wxPyBeginAllowThreads();
47335 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47336 wxPyEndAllowThreads(__tstate);
47337 if (PyErr_Occurred()) SWIG_fail;
47338 }
47339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47340 {
47341 if (temp7)
47342 delete arg7;
47343 }
47344 return resultobj;
47345 fail:
47346 {
47347 if (temp7)
47348 delete arg7;
47349 }
47350 return NULL;
47351 }
47352
47353
47354 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47355 PyObject *resultobj = 0;
47356 wxControl *result = 0 ;
47357
47358 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47359 {
47360 if (!wxPyCheckForApp()) SWIG_fail;
47361 PyThreadState* __tstate = wxPyBeginAllowThreads();
47362 result = (wxControl *)new wxControl();
47363 wxPyEndAllowThreads(__tstate);
47364 if (PyErr_Occurred()) SWIG_fail;
47365 }
47366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47367 return resultobj;
47368 fail:
47369 return NULL;
47370 }
47371
47372
47373 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47374 PyObject *resultobj = 0;
47375 wxControl *arg1 = (wxControl *) 0 ;
47376 wxWindow *arg2 = (wxWindow *) 0 ;
47377 int arg3 = (int) -1 ;
47378 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47379 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47380 wxSize const &arg5_defvalue = wxDefaultSize ;
47381 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47382 long arg6 = (long) 0 ;
47383 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47384 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47385 wxString const &arg8_defvalue = wxPyControlNameStr ;
47386 wxString *arg8 = (wxString *) &arg8_defvalue ;
47387 bool result;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 void *argp2 = 0 ;
47391 int res2 = 0 ;
47392 int val3 ;
47393 int ecode3 = 0 ;
47394 wxPoint temp4 ;
47395 wxSize temp5 ;
47396 long val6 ;
47397 int ecode6 = 0 ;
47398 void *argp7 = 0 ;
47399 int res7 = 0 ;
47400 bool temp8 = false ;
47401 PyObject * obj0 = 0 ;
47402 PyObject * obj1 = 0 ;
47403 PyObject * obj2 = 0 ;
47404 PyObject * obj3 = 0 ;
47405 PyObject * obj4 = 0 ;
47406 PyObject * obj5 = 0 ;
47407 PyObject * obj6 = 0 ;
47408 PyObject * obj7 = 0 ;
47409 char * kwnames[] = {
47410 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47411 };
47412
47413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47415 if (!SWIG_IsOK(res1)) {
47416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47417 }
47418 arg1 = reinterpret_cast< wxControl * >(argp1);
47419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47420 if (!SWIG_IsOK(res2)) {
47421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47422 }
47423 arg2 = reinterpret_cast< wxWindow * >(argp2);
47424 if (obj2) {
47425 ecode3 = SWIG_AsVal_int(obj2, &val3);
47426 if (!SWIG_IsOK(ecode3)) {
47427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47428 }
47429 arg3 = static_cast< int >(val3);
47430 }
47431 if (obj3) {
47432 {
47433 arg4 = &temp4;
47434 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47435 }
47436 }
47437 if (obj4) {
47438 {
47439 arg5 = &temp5;
47440 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47441 }
47442 }
47443 if (obj5) {
47444 ecode6 = SWIG_AsVal_long(obj5, &val6);
47445 if (!SWIG_IsOK(ecode6)) {
47446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47447 }
47448 arg6 = static_cast< long >(val6);
47449 }
47450 if (obj6) {
47451 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47452 if (!SWIG_IsOK(res7)) {
47453 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47454 }
47455 if (!argp7) {
47456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47457 }
47458 arg7 = reinterpret_cast< wxValidator * >(argp7);
47459 }
47460 if (obj7) {
47461 {
47462 arg8 = wxString_in_helper(obj7);
47463 if (arg8 == NULL) SWIG_fail;
47464 temp8 = true;
47465 }
47466 }
47467 {
47468 PyThreadState* __tstate = wxPyBeginAllowThreads();
47469 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47470 wxPyEndAllowThreads(__tstate);
47471 if (PyErr_Occurred()) SWIG_fail;
47472 }
47473 {
47474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47475 }
47476 {
47477 if (temp8)
47478 delete arg8;
47479 }
47480 return resultobj;
47481 fail:
47482 {
47483 if (temp8)
47484 delete arg8;
47485 }
47486 return NULL;
47487 }
47488
47489
47490 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47491 PyObject *resultobj = 0;
47492 wxControl *arg1 = (wxControl *) 0 ;
47493 int result;
47494 void *argp1 = 0 ;
47495 int res1 = 0 ;
47496 PyObject *swig_obj[1] ;
47497
47498 if (!args) SWIG_fail;
47499 swig_obj[0] = args;
47500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47501 if (!SWIG_IsOK(res1)) {
47502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47503 }
47504 arg1 = reinterpret_cast< wxControl * >(argp1);
47505 {
47506 PyThreadState* __tstate = wxPyBeginAllowThreads();
47507 result = (int)((wxControl const *)arg1)->GetAlignment();
47508 wxPyEndAllowThreads(__tstate);
47509 if (PyErr_Occurred()) SWIG_fail;
47510 }
47511 resultobj = SWIG_From_int(static_cast< int >(result));
47512 return resultobj;
47513 fail:
47514 return NULL;
47515 }
47516
47517
47518 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47519 PyObject *resultobj = 0;
47520 wxControl *arg1 = (wxControl *) 0 ;
47521 wxString result;
47522 void *argp1 = 0 ;
47523 int res1 = 0 ;
47524 PyObject *swig_obj[1] ;
47525
47526 if (!args) SWIG_fail;
47527 swig_obj[0] = args;
47528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47531 }
47532 arg1 = reinterpret_cast< wxControl * >(argp1);
47533 {
47534 PyThreadState* __tstate = wxPyBeginAllowThreads();
47535 result = ((wxControl const *)arg1)->GetLabelText();
47536 wxPyEndAllowThreads(__tstate);
47537 if (PyErr_Occurred()) SWIG_fail;
47538 }
47539 {
47540 #if wxUSE_UNICODE
47541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47542 #else
47543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47544 #endif
47545 }
47546 return resultobj;
47547 fail:
47548 return NULL;
47549 }
47550
47551
47552 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47553 PyObject *resultobj = 0;
47554 wxControl *arg1 = (wxControl *) 0 ;
47555 wxCommandEvent *arg2 = 0 ;
47556 void *argp1 = 0 ;
47557 int res1 = 0 ;
47558 void *argp2 = 0 ;
47559 int res2 = 0 ;
47560 PyObject * obj0 = 0 ;
47561 PyObject * obj1 = 0 ;
47562 char * kwnames[] = {
47563 (char *) "self",(char *) "event", NULL
47564 };
47565
47566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47568 if (!SWIG_IsOK(res1)) {
47569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47570 }
47571 arg1 = reinterpret_cast< wxControl * >(argp1);
47572 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47573 if (!SWIG_IsOK(res2)) {
47574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47575 }
47576 if (!argp2) {
47577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47578 }
47579 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47580 {
47581 PyThreadState* __tstate = wxPyBeginAllowThreads();
47582 (arg1)->Command(*arg2);
47583 wxPyEndAllowThreads(__tstate);
47584 if (PyErr_Occurred()) SWIG_fail;
47585 }
47586 resultobj = SWIG_Py_Void();
47587 return resultobj;
47588 fail:
47589 return NULL;
47590 }
47591
47592
47593 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47594 PyObject *resultobj = 0;
47595 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47596 SwigValueWrapper<wxVisualAttributes > result;
47597 int val1 ;
47598 int ecode1 = 0 ;
47599 PyObject * obj0 = 0 ;
47600 char * kwnames[] = {
47601 (char *) "variant", NULL
47602 };
47603
47604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47605 if (obj0) {
47606 ecode1 = SWIG_AsVal_int(obj0, &val1);
47607 if (!SWIG_IsOK(ecode1)) {
47608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47609 }
47610 arg1 = static_cast< wxWindowVariant >(val1);
47611 }
47612 {
47613 if (!wxPyCheckForApp()) SWIG_fail;
47614 PyThreadState* __tstate = wxPyBeginAllowThreads();
47615 result = wxControl::GetClassDefaultAttributes(arg1);
47616 wxPyEndAllowThreads(__tstate);
47617 if (PyErr_Occurred()) SWIG_fail;
47618 }
47619 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47620 return resultobj;
47621 fail:
47622 return NULL;
47623 }
47624
47625
47626 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47627 PyObject *obj;
47628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47629 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47630 return SWIG_Py_Void();
47631 }
47632
47633 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47634 return SWIG_Python_InitShadowInstance(args);
47635 }
47636
47637 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47638 PyObject *resultobj = 0;
47639 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47640 wxString *arg2 = 0 ;
47641 PyObject *arg3 = (PyObject *) NULL ;
47642 int result;
47643 void *argp1 = 0 ;
47644 int res1 = 0 ;
47645 bool temp2 = false ;
47646 PyObject * obj0 = 0 ;
47647 PyObject * obj1 = 0 ;
47648 PyObject * obj2 = 0 ;
47649 char * kwnames[] = {
47650 (char *) "self",(char *) "item",(char *) "clientData", NULL
47651 };
47652
47653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47655 if (!SWIG_IsOK(res1)) {
47656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47657 }
47658 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47659 {
47660 arg2 = wxString_in_helper(obj1);
47661 if (arg2 == NULL) SWIG_fail;
47662 temp2 = true;
47663 }
47664 if (obj2) {
47665 arg3 = obj2;
47666 }
47667 {
47668 PyThreadState* __tstate = wxPyBeginAllowThreads();
47669 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47670 wxPyEndAllowThreads(__tstate);
47671 if (PyErr_Occurred()) SWIG_fail;
47672 }
47673 resultobj = SWIG_From_int(static_cast< int >(result));
47674 {
47675 if (temp2)
47676 delete arg2;
47677 }
47678 return resultobj;
47679 fail:
47680 {
47681 if (temp2)
47682 delete arg2;
47683 }
47684 return NULL;
47685 }
47686
47687
47688 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47689 PyObject *resultobj = 0;
47690 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47691 wxArrayString *arg2 = 0 ;
47692 void *argp1 = 0 ;
47693 int res1 = 0 ;
47694 bool temp2 = false ;
47695 PyObject * obj0 = 0 ;
47696 PyObject * obj1 = 0 ;
47697 char * kwnames[] = {
47698 (char *) "self",(char *) "strings", NULL
47699 };
47700
47701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47703 if (!SWIG_IsOK(res1)) {
47704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47705 }
47706 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47707 {
47708 if (! PySequence_Check(obj1)) {
47709 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47710 SWIG_fail;
47711 }
47712 arg2 = new wxArrayString;
47713 temp2 = true;
47714 int i, len=PySequence_Length(obj1);
47715 for (i=0; i<len; i++) {
47716 PyObject* item = PySequence_GetItem(obj1, i);
47717 wxString* s = wxString_in_helper(item);
47718 if (PyErr_Occurred()) SWIG_fail;
47719 arg2->Add(*s);
47720 delete s;
47721 Py_DECREF(item);
47722 }
47723 }
47724 {
47725 PyThreadState* __tstate = wxPyBeginAllowThreads();
47726 (arg1)->Append((wxArrayString const &)*arg2);
47727 wxPyEndAllowThreads(__tstate);
47728 if (PyErr_Occurred()) SWIG_fail;
47729 }
47730 resultobj = SWIG_Py_Void();
47731 {
47732 if (temp2) delete arg2;
47733 }
47734 return resultobj;
47735 fail:
47736 {
47737 if (temp2) delete arg2;
47738 }
47739 return NULL;
47740 }
47741
47742
47743 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47744 PyObject *resultobj = 0;
47745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47746 wxString *arg2 = 0 ;
47747 unsigned int arg3 ;
47748 PyObject *arg4 = (PyObject *) NULL ;
47749 int result;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 bool temp2 = false ;
47753 unsigned int val3 ;
47754 int ecode3 = 0 ;
47755 PyObject * obj0 = 0 ;
47756 PyObject * obj1 = 0 ;
47757 PyObject * obj2 = 0 ;
47758 PyObject * obj3 = 0 ;
47759 char * kwnames[] = {
47760 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47761 };
47762
47763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47765 if (!SWIG_IsOK(res1)) {
47766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47767 }
47768 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47769 {
47770 arg2 = wxString_in_helper(obj1);
47771 if (arg2 == NULL) SWIG_fail;
47772 temp2 = true;
47773 }
47774 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47775 if (!SWIG_IsOK(ecode3)) {
47776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47777 }
47778 arg3 = static_cast< unsigned int >(val3);
47779 if (obj3) {
47780 arg4 = obj3;
47781 }
47782 {
47783 PyThreadState* __tstate = wxPyBeginAllowThreads();
47784 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47785 wxPyEndAllowThreads(__tstate);
47786 if (PyErr_Occurred()) SWIG_fail;
47787 }
47788 resultobj = SWIG_From_int(static_cast< int >(result));
47789 {
47790 if (temp2)
47791 delete arg2;
47792 }
47793 return resultobj;
47794 fail:
47795 {
47796 if (temp2)
47797 delete arg2;
47798 }
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47804 PyObject *resultobj = 0;
47805 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47806 void *argp1 = 0 ;
47807 int res1 = 0 ;
47808 PyObject *swig_obj[1] ;
47809
47810 if (!args) SWIG_fail;
47811 swig_obj[0] = args;
47812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47813 if (!SWIG_IsOK(res1)) {
47814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47815 }
47816 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47817 {
47818 PyThreadState* __tstate = wxPyBeginAllowThreads();
47819 (arg1)->Clear();
47820 wxPyEndAllowThreads(__tstate);
47821 if (PyErr_Occurred()) SWIG_fail;
47822 }
47823 resultobj = SWIG_Py_Void();
47824 return resultobj;
47825 fail:
47826 return NULL;
47827 }
47828
47829
47830 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47831 PyObject *resultobj = 0;
47832 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47833 unsigned int arg2 ;
47834 void *argp1 = 0 ;
47835 int res1 = 0 ;
47836 unsigned int val2 ;
47837 int ecode2 = 0 ;
47838 PyObject * obj0 = 0 ;
47839 PyObject * obj1 = 0 ;
47840 char * kwnames[] = {
47841 (char *) "self",(char *) "n", NULL
47842 };
47843
47844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47846 if (!SWIG_IsOK(res1)) {
47847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47848 }
47849 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47850 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47851 if (!SWIG_IsOK(ecode2)) {
47852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47853 }
47854 arg2 = static_cast< unsigned int >(val2);
47855 {
47856 PyThreadState* __tstate = wxPyBeginAllowThreads();
47857 (arg1)->Delete(arg2);
47858 wxPyEndAllowThreads(__tstate);
47859 if (PyErr_Occurred()) SWIG_fail;
47860 }
47861 resultobj = SWIG_Py_Void();
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47869 PyObject *resultobj = 0;
47870 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47871 unsigned int arg2 ;
47872 PyObject *result = 0 ;
47873 void *argp1 = 0 ;
47874 int res1 = 0 ;
47875 unsigned int val2 ;
47876 int ecode2 = 0 ;
47877 PyObject * obj0 = 0 ;
47878 PyObject * obj1 = 0 ;
47879 char * kwnames[] = {
47880 (char *) "self",(char *) "n", NULL
47881 };
47882
47883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47885 if (!SWIG_IsOK(res1)) {
47886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47887 }
47888 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47889 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47890 if (!SWIG_IsOK(ecode2)) {
47891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47892 }
47893 arg2 = static_cast< unsigned int >(val2);
47894 {
47895 PyThreadState* __tstate = wxPyBeginAllowThreads();
47896 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47897 wxPyEndAllowThreads(__tstate);
47898 if (PyErr_Occurred()) SWIG_fail;
47899 }
47900 resultobj = result;
47901 return resultobj;
47902 fail:
47903 return NULL;
47904 }
47905
47906
47907 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47908 PyObject *resultobj = 0;
47909 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47910 unsigned int arg2 ;
47911 PyObject *arg3 = (PyObject *) 0 ;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 unsigned int val2 ;
47915 int ecode2 = 0 ;
47916 PyObject * obj0 = 0 ;
47917 PyObject * obj1 = 0 ;
47918 PyObject * obj2 = 0 ;
47919 char * kwnames[] = {
47920 (char *) "self",(char *) "n",(char *) "clientData", NULL
47921 };
47922
47923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47925 if (!SWIG_IsOK(res1)) {
47926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47927 }
47928 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47929 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47930 if (!SWIG_IsOK(ecode2)) {
47931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47932 }
47933 arg2 = static_cast< unsigned int >(val2);
47934 arg3 = obj2;
47935 {
47936 PyThreadState* __tstate = wxPyBeginAllowThreads();
47937 wxItemContainer_SetClientData(arg1,arg2,arg3);
47938 wxPyEndAllowThreads(__tstate);
47939 if (PyErr_Occurred()) SWIG_fail;
47940 }
47941 resultobj = SWIG_Py_Void();
47942 return resultobj;
47943 fail:
47944 return NULL;
47945 }
47946
47947
47948 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47949 PyObject *resultobj = 0;
47950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47951 unsigned int result;
47952 void *argp1 = 0 ;
47953 int res1 = 0 ;
47954 PyObject *swig_obj[1] ;
47955
47956 if (!args) SWIG_fail;
47957 swig_obj[0] = args;
47958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47959 if (!SWIG_IsOK(res1)) {
47960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47961 }
47962 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47970 return resultobj;
47971 fail:
47972 return NULL;
47973 }
47974
47975
47976 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47977 PyObject *resultobj = 0;
47978 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47979 bool result;
47980 void *argp1 = 0 ;
47981 int res1 = 0 ;
47982 PyObject *swig_obj[1] ;
47983
47984 if (!args) SWIG_fail;
47985 swig_obj[0] = args;
47986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47989 }
47990 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47991 {
47992 PyThreadState* __tstate = wxPyBeginAllowThreads();
47993 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47994 wxPyEndAllowThreads(__tstate);
47995 if (PyErr_Occurred()) SWIG_fail;
47996 }
47997 {
47998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47999 }
48000 return resultobj;
48001 fail:
48002 return NULL;
48003 }
48004
48005
48006 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48007 PyObject *resultobj = 0;
48008 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48009 unsigned int arg2 ;
48010 wxString result;
48011 void *argp1 = 0 ;
48012 int res1 = 0 ;
48013 unsigned int val2 ;
48014 int ecode2 = 0 ;
48015 PyObject * obj0 = 0 ;
48016 PyObject * obj1 = 0 ;
48017 char * kwnames[] = {
48018 (char *) "self",(char *) "n", NULL
48019 };
48020
48021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48023 if (!SWIG_IsOK(res1)) {
48024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48025 }
48026 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48027 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48028 if (!SWIG_IsOK(ecode2)) {
48029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48030 }
48031 arg2 = static_cast< unsigned int >(val2);
48032 {
48033 PyThreadState* __tstate = wxPyBeginAllowThreads();
48034 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48035 wxPyEndAllowThreads(__tstate);
48036 if (PyErr_Occurred()) SWIG_fail;
48037 }
48038 {
48039 #if wxUSE_UNICODE
48040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48041 #else
48042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48043 #endif
48044 }
48045 return resultobj;
48046 fail:
48047 return NULL;
48048 }
48049
48050
48051 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48052 PyObject *resultobj = 0;
48053 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48054 wxArrayString result;
48055 void *argp1 = 0 ;
48056 int res1 = 0 ;
48057 PyObject *swig_obj[1] ;
48058
48059 if (!args) SWIG_fail;
48060 swig_obj[0] = args;
48061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48062 if (!SWIG_IsOK(res1)) {
48063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48064 }
48065 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48066 {
48067 PyThreadState* __tstate = wxPyBeginAllowThreads();
48068 result = ((wxItemContainer const *)arg1)->GetStrings();
48069 wxPyEndAllowThreads(__tstate);
48070 if (PyErr_Occurred()) SWIG_fail;
48071 }
48072 {
48073 resultobj = wxArrayString2PyList_helper(result);
48074 }
48075 return resultobj;
48076 fail:
48077 return NULL;
48078 }
48079
48080
48081 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48082 PyObject *resultobj = 0;
48083 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48084 unsigned int arg2 ;
48085 wxString *arg3 = 0 ;
48086 void *argp1 = 0 ;
48087 int res1 = 0 ;
48088 unsigned int val2 ;
48089 int ecode2 = 0 ;
48090 bool temp3 = false ;
48091 PyObject * obj0 = 0 ;
48092 PyObject * obj1 = 0 ;
48093 PyObject * obj2 = 0 ;
48094 char * kwnames[] = {
48095 (char *) "self",(char *) "n",(char *) "s", NULL
48096 };
48097
48098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48100 if (!SWIG_IsOK(res1)) {
48101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48102 }
48103 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48104 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48105 if (!SWIG_IsOK(ecode2)) {
48106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48107 }
48108 arg2 = static_cast< unsigned int >(val2);
48109 {
48110 arg3 = wxString_in_helper(obj2);
48111 if (arg3 == NULL) SWIG_fail;
48112 temp3 = true;
48113 }
48114 {
48115 PyThreadState* __tstate = wxPyBeginAllowThreads();
48116 (arg1)->SetString(arg2,(wxString const &)*arg3);
48117 wxPyEndAllowThreads(__tstate);
48118 if (PyErr_Occurred()) SWIG_fail;
48119 }
48120 resultobj = SWIG_Py_Void();
48121 {
48122 if (temp3)
48123 delete arg3;
48124 }
48125 return resultobj;
48126 fail:
48127 {
48128 if (temp3)
48129 delete arg3;
48130 }
48131 return NULL;
48132 }
48133
48134
48135 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48136 PyObject *resultobj = 0;
48137 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48138 wxString *arg2 = 0 ;
48139 int result;
48140 void *argp1 = 0 ;
48141 int res1 = 0 ;
48142 bool temp2 = false ;
48143 PyObject * obj0 = 0 ;
48144 PyObject * obj1 = 0 ;
48145 char * kwnames[] = {
48146 (char *) "self",(char *) "s", NULL
48147 };
48148
48149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48151 if (!SWIG_IsOK(res1)) {
48152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48153 }
48154 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48155 {
48156 arg2 = wxString_in_helper(obj1);
48157 if (arg2 == NULL) SWIG_fail;
48158 temp2 = true;
48159 }
48160 {
48161 PyThreadState* __tstate = wxPyBeginAllowThreads();
48162 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48163 wxPyEndAllowThreads(__tstate);
48164 if (PyErr_Occurred()) SWIG_fail;
48165 }
48166 resultobj = SWIG_From_int(static_cast< int >(result));
48167 {
48168 if (temp2)
48169 delete arg2;
48170 }
48171 return resultobj;
48172 fail:
48173 {
48174 if (temp2)
48175 delete arg2;
48176 }
48177 return NULL;
48178 }
48179
48180
48181 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48182 PyObject *resultobj = 0;
48183 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48184 int arg2 ;
48185 void *argp1 = 0 ;
48186 int res1 = 0 ;
48187 int val2 ;
48188 int ecode2 = 0 ;
48189 PyObject * obj0 = 0 ;
48190 PyObject * obj1 = 0 ;
48191 char * kwnames[] = {
48192 (char *) "self",(char *) "n", NULL
48193 };
48194
48195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48197 if (!SWIG_IsOK(res1)) {
48198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48199 }
48200 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48201 ecode2 = SWIG_AsVal_int(obj1, &val2);
48202 if (!SWIG_IsOK(ecode2)) {
48203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48204 }
48205 arg2 = static_cast< int >(val2);
48206 {
48207 PyThreadState* __tstate = wxPyBeginAllowThreads();
48208 (arg1)->SetSelection(arg2);
48209 wxPyEndAllowThreads(__tstate);
48210 if (PyErr_Occurred()) SWIG_fail;
48211 }
48212 resultobj = SWIG_Py_Void();
48213 return resultobj;
48214 fail:
48215 return NULL;
48216 }
48217
48218
48219 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48220 PyObject *resultobj = 0;
48221 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48222 int result;
48223 void *argp1 = 0 ;
48224 int res1 = 0 ;
48225 PyObject *swig_obj[1] ;
48226
48227 if (!args) SWIG_fail;
48228 swig_obj[0] = args;
48229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48232 }
48233 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48234 {
48235 PyThreadState* __tstate = wxPyBeginAllowThreads();
48236 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48237 wxPyEndAllowThreads(__tstate);
48238 if (PyErr_Occurred()) SWIG_fail;
48239 }
48240 resultobj = SWIG_From_int(static_cast< int >(result));
48241 return resultobj;
48242 fail:
48243 return NULL;
48244 }
48245
48246
48247 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48248 PyObject *resultobj = 0;
48249 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48250 wxString *arg2 = 0 ;
48251 bool result;
48252 void *argp1 = 0 ;
48253 int res1 = 0 ;
48254 bool temp2 = false ;
48255 PyObject * obj0 = 0 ;
48256 PyObject * obj1 = 0 ;
48257 char * kwnames[] = {
48258 (char *) "self",(char *) "s", NULL
48259 };
48260
48261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48265 }
48266 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48267 {
48268 arg2 = wxString_in_helper(obj1);
48269 if (arg2 == NULL) SWIG_fail;
48270 temp2 = true;
48271 }
48272 {
48273 PyThreadState* __tstate = wxPyBeginAllowThreads();
48274 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48275 wxPyEndAllowThreads(__tstate);
48276 if (PyErr_Occurred()) SWIG_fail;
48277 }
48278 {
48279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48280 }
48281 {
48282 if (temp2)
48283 delete arg2;
48284 }
48285 return resultobj;
48286 fail:
48287 {
48288 if (temp2)
48289 delete arg2;
48290 }
48291 return NULL;
48292 }
48293
48294
48295 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48296 PyObject *resultobj = 0;
48297 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48298 wxString result;
48299 void *argp1 = 0 ;
48300 int res1 = 0 ;
48301 PyObject *swig_obj[1] ;
48302
48303 if (!args) SWIG_fail;
48304 swig_obj[0] = args;
48305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48306 if (!SWIG_IsOK(res1)) {
48307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48308 }
48309 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48310 {
48311 PyThreadState* __tstate = wxPyBeginAllowThreads();
48312 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48313 wxPyEndAllowThreads(__tstate);
48314 if (PyErr_Occurred()) SWIG_fail;
48315 }
48316 {
48317 #if wxUSE_UNICODE
48318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48319 #else
48320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48321 #endif
48322 }
48323 return resultobj;
48324 fail:
48325 return NULL;
48326 }
48327
48328
48329 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48330 PyObject *resultobj = 0;
48331 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48332 int arg2 ;
48333 void *argp1 = 0 ;
48334 int res1 = 0 ;
48335 int val2 ;
48336 int ecode2 = 0 ;
48337 PyObject * obj0 = 0 ;
48338 PyObject * obj1 = 0 ;
48339 char * kwnames[] = {
48340 (char *) "self",(char *) "n", NULL
48341 };
48342
48343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48345 if (!SWIG_IsOK(res1)) {
48346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48347 }
48348 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48349 ecode2 = SWIG_AsVal_int(obj1, &val2);
48350 if (!SWIG_IsOK(ecode2)) {
48351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48352 }
48353 arg2 = static_cast< int >(val2);
48354 {
48355 PyThreadState* __tstate = wxPyBeginAllowThreads();
48356 (arg1)->Select(arg2);
48357 wxPyEndAllowThreads(__tstate);
48358 if (PyErr_Occurred()) SWIG_fail;
48359 }
48360 resultobj = SWIG_Py_Void();
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48368 PyObject *obj;
48369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48370 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48371 return SWIG_Py_Void();
48372 }
48373
48374 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48375 PyObject *obj;
48376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48377 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48378 return SWIG_Py_Void();
48379 }
48380
48381 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48382 PyObject *resultobj = 0;
48383 wxSizerItem *result = 0 ;
48384
48385 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48386 {
48387 PyThreadState* __tstate = wxPyBeginAllowThreads();
48388 result = (wxSizerItem *)new wxSizerItem();
48389 wxPyEndAllowThreads(__tstate);
48390 if (PyErr_Occurred()) SWIG_fail;
48391 }
48392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48393 return resultobj;
48394 fail:
48395 return NULL;
48396 }
48397
48398
48399 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48400 PyObject *resultobj = 0;
48401 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48402 void *argp1 = 0 ;
48403 int res1 = 0 ;
48404 PyObject *swig_obj[1] ;
48405
48406 if (!args) SWIG_fail;
48407 swig_obj[0] = args;
48408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48409 if (!SWIG_IsOK(res1)) {
48410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48411 }
48412 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48413 {
48414 PyThreadState* __tstate = wxPyBeginAllowThreads();
48415 delete arg1;
48416
48417 wxPyEndAllowThreads(__tstate);
48418 if (PyErr_Occurred()) SWIG_fail;
48419 }
48420 resultobj = SWIG_Py_Void();
48421 return resultobj;
48422 fail:
48423 return NULL;
48424 }
48425
48426
48427 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48428 PyObject *resultobj = 0;
48429 wxWindow *arg1 = (wxWindow *) 0 ;
48430 int arg2 ;
48431 int arg3 ;
48432 int arg4 ;
48433 PyObject *arg5 = (PyObject *) NULL ;
48434 wxSizerItem *result = 0 ;
48435 void *argp1 = 0 ;
48436 int res1 = 0 ;
48437 int val2 ;
48438 int ecode2 = 0 ;
48439 int val3 ;
48440 int ecode3 = 0 ;
48441 int val4 ;
48442 int ecode4 = 0 ;
48443 PyObject * obj0 = 0 ;
48444 PyObject * obj1 = 0 ;
48445 PyObject * obj2 = 0 ;
48446 PyObject * obj3 = 0 ;
48447 PyObject * obj4 = 0 ;
48448 char * kwnames[] = {
48449 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48450 };
48451
48452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48454 if (!SWIG_IsOK(res1)) {
48455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48456 }
48457 arg1 = reinterpret_cast< wxWindow * >(argp1);
48458 ecode2 = SWIG_AsVal_int(obj1, &val2);
48459 if (!SWIG_IsOK(ecode2)) {
48460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48461 }
48462 arg2 = static_cast< int >(val2);
48463 ecode3 = SWIG_AsVal_int(obj2, &val3);
48464 if (!SWIG_IsOK(ecode3)) {
48465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48466 }
48467 arg3 = static_cast< int >(val3);
48468 ecode4 = SWIG_AsVal_int(obj3, &val4);
48469 if (!SWIG_IsOK(ecode4)) {
48470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48471 }
48472 arg4 = static_cast< int >(val4);
48473 if (obj4) {
48474 arg5 = obj4;
48475 }
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48490 PyObject *resultobj = 0;
48491 int arg1 ;
48492 int arg2 ;
48493 int arg3 ;
48494 int arg4 ;
48495 int arg5 ;
48496 PyObject *arg6 = (PyObject *) NULL ;
48497 wxSizerItem *result = 0 ;
48498 int val1 ;
48499 int ecode1 = 0 ;
48500 int val2 ;
48501 int ecode2 = 0 ;
48502 int val3 ;
48503 int ecode3 = 0 ;
48504 int val4 ;
48505 int ecode4 = 0 ;
48506 int val5 ;
48507 int ecode5 = 0 ;
48508 PyObject * obj0 = 0 ;
48509 PyObject * obj1 = 0 ;
48510 PyObject * obj2 = 0 ;
48511 PyObject * obj3 = 0 ;
48512 PyObject * obj4 = 0 ;
48513 PyObject * obj5 = 0 ;
48514 char * kwnames[] = {
48515 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48516 };
48517
48518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48519 ecode1 = SWIG_AsVal_int(obj0, &val1);
48520 if (!SWIG_IsOK(ecode1)) {
48521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48522 }
48523 arg1 = static_cast< int >(val1);
48524 ecode2 = SWIG_AsVal_int(obj1, &val2);
48525 if (!SWIG_IsOK(ecode2)) {
48526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48527 }
48528 arg2 = static_cast< int >(val2);
48529 ecode3 = SWIG_AsVal_int(obj2, &val3);
48530 if (!SWIG_IsOK(ecode3)) {
48531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48532 }
48533 arg3 = static_cast< int >(val3);
48534 ecode4 = SWIG_AsVal_int(obj3, &val4);
48535 if (!SWIG_IsOK(ecode4)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48537 }
48538 arg4 = static_cast< int >(val4);
48539 ecode5 = SWIG_AsVal_int(obj4, &val5);
48540 if (!SWIG_IsOK(ecode5)) {
48541 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48542 }
48543 arg5 = static_cast< int >(val5);
48544 if (obj5) {
48545 arg6 = obj5;
48546 }
48547 {
48548 PyThreadState* __tstate = wxPyBeginAllowThreads();
48549 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48550 wxPyEndAllowThreads(__tstate);
48551 if (PyErr_Occurred()) SWIG_fail;
48552 }
48553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48554 return resultobj;
48555 fail:
48556 return NULL;
48557 }
48558
48559
48560 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48561 PyObject *resultobj = 0;
48562 wxSizer *arg1 = (wxSizer *) 0 ;
48563 int arg2 ;
48564 int arg3 ;
48565 int arg4 ;
48566 PyObject *arg5 = (PyObject *) NULL ;
48567 wxSizerItem *result = 0 ;
48568 int res1 = 0 ;
48569 int val2 ;
48570 int ecode2 = 0 ;
48571 int val3 ;
48572 int ecode3 = 0 ;
48573 int val4 ;
48574 int ecode4 = 0 ;
48575 PyObject * obj0 = 0 ;
48576 PyObject * obj1 = 0 ;
48577 PyObject * obj2 = 0 ;
48578 PyObject * obj3 = 0 ;
48579 PyObject * obj4 = 0 ;
48580 char * kwnames[] = {
48581 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48582 };
48583
48584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48585 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48586 if (!SWIG_IsOK(res1)) {
48587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48588 }
48589 ecode2 = SWIG_AsVal_int(obj1, &val2);
48590 if (!SWIG_IsOK(ecode2)) {
48591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48592 }
48593 arg2 = static_cast< int >(val2);
48594 ecode3 = SWIG_AsVal_int(obj2, &val3);
48595 if (!SWIG_IsOK(ecode3)) {
48596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48597 }
48598 arg3 = static_cast< int >(val3);
48599 ecode4 = SWIG_AsVal_int(obj3, &val4);
48600 if (!SWIG_IsOK(ecode4)) {
48601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48602 }
48603 arg4 = static_cast< int >(val4);
48604 if (obj4) {
48605 arg5 = obj4;
48606 }
48607 {
48608 PyThreadState* __tstate = wxPyBeginAllowThreads();
48609 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48610 wxPyEndAllowThreads(__tstate);
48611 if (PyErr_Occurred()) SWIG_fail;
48612 }
48613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48614 return resultobj;
48615 fail:
48616 return NULL;
48617 }
48618
48619
48620 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48621 PyObject *resultobj = 0;
48622 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48623 void *argp1 = 0 ;
48624 int res1 = 0 ;
48625 PyObject *swig_obj[1] ;
48626
48627 if (!args) SWIG_fail;
48628 swig_obj[0] = args;
48629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48630 if (!SWIG_IsOK(res1)) {
48631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48632 }
48633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48634 {
48635 PyThreadState* __tstate = wxPyBeginAllowThreads();
48636 (arg1)->DeleteWindows();
48637 wxPyEndAllowThreads(__tstate);
48638 if (PyErr_Occurred()) SWIG_fail;
48639 }
48640 resultobj = SWIG_Py_Void();
48641 return resultobj;
48642 fail:
48643 return NULL;
48644 }
48645
48646
48647 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48648 PyObject *resultobj = 0;
48649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48650 void *argp1 = 0 ;
48651 int res1 = 0 ;
48652 PyObject *swig_obj[1] ;
48653
48654 if (!args) SWIG_fail;
48655 swig_obj[0] = args;
48656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48657 if (!SWIG_IsOK(res1)) {
48658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48659 }
48660 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 (arg1)->DetachSizer();
48664 wxPyEndAllowThreads(__tstate);
48665 if (PyErr_Occurred()) SWIG_fail;
48666 }
48667 resultobj = SWIG_Py_Void();
48668 return resultobj;
48669 fail:
48670 return NULL;
48671 }
48672
48673
48674 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48675 PyObject *resultobj = 0;
48676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48677 wxSize result;
48678 void *argp1 = 0 ;
48679 int res1 = 0 ;
48680 PyObject *swig_obj[1] ;
48681
48682 if (!args) SWIG_fail;
48683 swig_obj[0] = args;
48684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48685 if (!SWIG_IsOK(res1)) {
48686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48687 }
48688 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48689 {
48690 PyThreadState* __tstate = wxPyBeginAllowThreads();
48691 result = (arg1)->GetSize();
48692 wxPyEndAllowThreads(__tstate);
48693 if (PyErr_Occurred()) SWIG_fail;
48694 }
48695 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48696 return resultobj;
48697 fail:
48698 return NULL;
48699 }
48700
48701
48702 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48703 PyObject *resultobj = 0;
48704 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48705 wxSize result;
48706 void *argp1 = 0 ;
48707 int res1 = 0 ;
48708 PyObject *swig_obj[1] ;
48709
48710 if (!args) SWIG_fail;
48711 swig_obj[0] = args;
48712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48713 if (!SWIG_IsOK(res1)) {
48714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48715 }
48716 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48717 {
48718 PyThreadState* __tstate = wxPyBeginAllowThreads();
48719 result = (arg1)->CalcMin();
48720 wxPyEndAllowThreads(__tstate);
48721 if (PyErr_Occurred()) SWIG_fail;
48722 }
48723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48731 PyObject *resultobj = 0;
48732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48733 wxPoint *arg2 = 0 ;
48734 wxSize *arg3 = 0 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 wxPoint temp2 ;
48738 wxSize temp3 ;
48739 PyObject * obj0 = 0 ;
48740 PyObject * obj1 = 0 ;
48741 PyObject * obj2 = 0 ;
48742 char * kwnames[] = {
48743 (char *) "self",(char *) "pos",(char *) "size", NULL
48744 };
48745
48746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48748 if (!SWIG_IsOK(res1)) {
48749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48750 }
48751 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48752 {
48753 arg2 = &temp2;
48754 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48755 }
48756 {
48757 arg3 = &temp3;
48758 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48759 }
48760 {
48761 PyThreadState* __tstate = wxPyBeginAllowThreads();
48762 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48763 wxPyEndAllowThreads(__tstate);
48764 if (PyErr_Occurred()) SWIG_fail;
48765 }
48766 resultobj = SWIG_Py_Void();
48767 return resultobj;
48768 fail:
48769 return NULL;
48770 }
48771
48772
48773 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48774 PyObject *resultobj = 0;
48775 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48776 wxSize result;
48777 void *argp1 = 0 ;
48778 int res1 = 0 ;
48779 PyObject *swig_obj[1] ;
48780
48781 if (!args) SWIG_fail;
48782 swig_obj[0] = args;
48783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48784 if (!SWIG_IsOK(res1)) {
48785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48786 }
48787 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48788 {
48789 PyThreadState* __tstate = wxPyBeginAllowThreads();
48790 result = (arg1)->GetMinSize();
48791 wxPyEndAllowThreads(__tstate);
48792 if (PyErr_Occurred()) SWIG_fail;
48793 }
48794 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48795 return resultobj;
48796 fail:
48797 return NULL;
48798 }
48799
48800
48801 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48802 PyObject *resultobj = 0;
48803 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48804 wxSize result;
48805 void *argp1 = 0 ;
48806 int res1 = 0 ;
48807 PyObject *swig_obj[1] ;
48808
48809 if (!args) SWIG_fail;
48810 swig_obj[0] = args;
48811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48812 if (!SWIG_IsOK(res1)) {
48813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48814 }
48815 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48816 {
48817 PyThreadState* __tstate = wxPyBeginAllowThreads();
48818 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48819 wxPyEndAllowThreads(__tstate);
48820 if (PyErr_Occurred()) SWIG_fail;
48821 }
48822 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48823 return resultobj;
48824 fail:
48825 return NULL;
48826 }
48827
48828
48829 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48830 PyObject *resultobj = 0;
48831 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48832 int arg2 ;
48833 int arg3 ;
48834 void *argp1 = 0 ;
48835 int res1 = 0 ;
48836 int val2 ;
48837 int ecode2 = 0 ;
48838 int val3 ;
48839 int ecode3 = 0 ;
48840 PyObject * obj0 = 0 ;
48841 PyObject * obj1 = 0 ;
48842 PyObject * obj2 = 0 ;
48843 char * kwnames[] = {
48844 (char *) "self",(char *) "x",(char *) "y", NULL
48845 };
48846
48847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48849 if (!SWIG_IsOK(res1)) {
48850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48851 }
48852 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48853 ecode2 = SWIG_AsVal_int(obj1, &val2);
48854 if (!SWIG_IsOK(ecode2)) {
48855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48856 }
48857 arg2 = static_cast< int >(val2);
48858 ecode3 = SWIG_AsVal_int(obj2, &val3);
48859 if (!SWIG_IsOK(ecode3)) {
48860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48861 }
48862 arg3 = static_cast< int >(val3);
48863 {
48864 PyThreadState* __tstate = wxPyBeginAllowThreads();
48865 (arg1)->SetInitSize(arg2,arg3);
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 resultobj = SWIG_Py_Void();
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48877 PyObject *resultobj = 0;
48878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48879 int arg2 ;
48880 int arg3 ;
48881 void *argp1 = 0 ;
48882 int res1 = 0 ;
48883 int val2 ;
48884 int ecode2 = 0 ;
48885 int val3 ;
48886 int ecode3 = 0 ;
48887 PyObject * obj0 = 0 ;
48888 PyObject * obj1 = 0 ;
48889 PyObject * obj2 = 0 ;
48890 char * kwnames[] = {
48891 (char *) "self",(char *) "width",(char *) "height", NULL
48892 };
48893
48894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48896 if (!SWIG_IsOK(res1)) {
48897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48898 }
48899 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48900 ecode2 = SWIG_AsVal_int(obj1, &val2);
48901 if (!SWIG_IsOK(ecode2)) {
48902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48903 }
48904 arg2 = static_cast< int >(val2);
48905 ecode3 = SWIG_AsVal_int(obj2, &val3);
48906 if (!SWIG_IsOK(ecode3)) {
48907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48908 }
48909 arg3 = static_cast< int >(val3);
48910 {
48911 PyThreadState* __tstate = wxPyBeginAllowThreads();
48912 (arg1)->SetRatio(arg2,arg3);
48913 wxPyEndAllowThreads(__tstate);
48914 if (PyErr_Occurred()) SWIG_fail;
48915 }
48916 resultobj = SWIG_Py_Void();
48917 return resultobj;
48918 fail:
48919 return NULL;
48920 }
48921
48922
48923 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48924 PyObject *resultobj = 0;
48925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48926 wxSize *arg2 = 0 ;
48927 void *argp1 = 0 ;
48928 int res1 = 0 ;
48929 wxSize temp2 ;
48930 PyObject * obj0 = 0 ;
48931 PyObject * obj1 = 0 ;
48932 char * kwnames[] = {
48933 (char *) "self",(char *) "size", NULL
48934 };
48935
48936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48938 if (!SWIG_IsOK(res1)) {
48939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48940 }
48941 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48942 {
48943 arg2 = &temp2;
48944 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48945 }
48946 {
48947 PyThreadState* __tstate = wxPyBeginAllowThreads();
48948 (arg1)->SetRatio((wxSize const &)*arg2);
48949 wxPyEndAllowThreads(__tstate);
48950 if (PyErr_Occurred()) SWIG_fail;
48951 }
48952 resultobj = SWIG_Py_Void();
48953 return resultobj;
48954 fail:
48955 return NULL;
48956 }
48957
48958
48959 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48960 PyObject *resultobj = 0;
48961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48962 float arg2 ;
48963 void *argp1 = 0 ;
48964 int res1 = 0 ;
48965 float val2 ;
48966 int ecode2 = 0 ;
48967 PyObject * obj0 = 0 ;
48968 PyObject * obj1 = 0 ;
48969 char * kwnames[] = {
48970 (char *) "self",(char *) "ratio", NULL
48971 };
48972
48973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48975 if (!SWIG_IsOK(res1)) {
48976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48977 }
48978 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48979 ecode2 = SWIG_AsVal_float(obj1, &val2);
48980 if (!SWIG_IsOK(ecode2)) {
48981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48982 }
48983 arg2 = static_cast< float >(val2);
48984 {
48985 PyThreadState* __tstate = wxPyBeginAllowThreads();
48986 (arg1)->SetRatio(arg2);
48987 wxPyEndAllowThreads(__tstate);
48988 if (PyErr_Occurred()) SWIG_fail;
48989 }
48990 resultobj = SWIG_Py_Void();
48991 return resultobj;
48992 fail:
48993 return NULL;
48994 }
48995
48996
48997 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48998 PyObject *resultobj = 0;
48999 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49000 float result;
49001 void *argp1 = 0 ;
49002 int res1 = 0 ;
49003 PyObject *swig_obj[1] ;
49004
49005 if (!args) SWIG_fail;
49006 swig_obj[0] = args;
49007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49008 if (!SWIG_IsOK(res1)) {
49009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49010 }
49011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49012 {
49013 PyThreadState* __tstate = wxPyBeginAllowThreads();
49014 result = (float)(arg1)->GetRatio();
49015 wxPyEndAllowThreads(__tstate);
49016 if (PyErr_Occurred()) SWIG_fail;
49017 }
49018 resultobj = SWIG_From_float(static_cast< float >(result));
49019 return resultobj;
49020 fail:
49021 return NULL;
49022 }
49023
49024
49025 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49026 PyObject *resultobj = 0;
49027 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49028 wxRect result;
49029 void *argp1 = 0 ;
49030 int res1 = 0 ;
49031 PyObject *swig_obj[1] ;
49032
49033 if (!args) SWIG_fail;
49034 swig_obj[0] = args;
49035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49036 if (!SWIG_IsOK(res1)) {
49037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49038 }
49039 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49040 {
49041 PyThreadState* __tstate = wxPyBeginAllowThreads();
49042 result = (arg1)->GetRect();
49043 wxPyEndAllowThreads(__tstate);
49044 if (PyErr_Occurred()) SWIG_fail;
49045 }
49046 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49047 return resultobj;
49048 fail:
49049 return NULL;
49050 }
49051
49052
49053 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49054 PyObject *resultobj = 0;
49055 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49056 bool result;
49057 void *argp1 = 0 ;
49058 int res1 = 0 ;
49059 PyObject *swig_obj[1] ;
49060
49061 if (!args) SWIG_fail;
49062 swig_obj[0] = args;
49063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49064 if (!SWIG_IsOK(res1)) {
49065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49066 }
49067 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49068 {
49069 PyThreadState* __tstate = wxPyBeginAllowThreads();
49070 result = (bool)(arg1)->IsWindow();
49071 wxPyEndAllowThreads(__tstate);
49072 if (PyErr_Occurred()) SWIG_fail;
49073 }
49074 {
49075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49076 }
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49084 PyObject *resultobj = 0;
49085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49086 bool result;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 PyObject *swig_obj[1] ;
49090
49091 if (!args) SWIG_fail;
49092 swig_obj[0] = args;
49093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49096 }
49097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49098 {
49099 PyThreadState* __tstate = wxPyBeginAllowThreads();
49100 result = (bool)(arg1)->IsSizer();
49101 wxPyEndAllowThreads(__tstate);
49102 if (PyErr_Occurred()) SWIG_fail;
49103 }
49104 {
49105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49106 }
49107 return resultobj;
49108 fail:
49109 return NULL;
49110 }
49111
49112
49113 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49114 PyObject *resultobj = 0;
49115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49116 bool result;
49117 void *argp1 = 0 ;
49118 int res1 = 0 ;
49119 PyObject *swig_obj[1] ;
49120
49121 if (!args) SWIG_fail;
49122 swig_obj[0] = args;
49123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49124 if (!SWIG_IsOK(res1)) {
49125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49126 }
49127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 result = (bool)(arg1)->IsSpacer();
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 {
49135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49136 }
49137 return resultobj;
49138 fail:
49139 return NULL;
49140 }
49141
49142
49143 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49144 PyObject *resultobj = 0;
49145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49146 int arg2 ;
49147 void *argp1 = 0 ;
49148 int res1 = 0 ;
49149 int val2 ;
49150 int ecode2 = 0 ;
49151 PyObject * obj0 = 0 ;
49152 PyObject * obj1 = 0 ;
49153 char * kwnames[] = {
49154 (char *) "self",(char *) "proportion", NULL
49155 };
49156
49157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49159 if (!SWIG_IsOK(res1)) {
49160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49161 }
49162 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49163 ecode2 = SWIG_AsVal_int(obj1, &val2);
49164 if (!SWIG_IsOK(ecode2)) {
49165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49166 }
49167 arg2 = static_cast< int >(val2);
49168 {
49169 PyThreadState* __tstate = wxPyBeginAllowThreads();
49170 (arg1)->SetProportion(arg2);
49171 wxPyEndAllowThreads(__tstate);
49172 if (PyErr_Occurred()) SWIG_fail;
49173 }
49174 resultobj = SWIG_Py_Void();
49175 return resultobj;
49176 fail:
49177 return NULL;
49178 }
49179
49180
49181 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49182 PyObject *resultobj = 0;
49183 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49184 int result;
49185 void *argp1 = 0 ;
49186 int res1 = 0 ;
49187 PyObject *swig_obj[1] ;
49188
49189 if (!args) SWIG_fail;
49190 swig_obj[0] = args;
49191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49192 if (!SWIG_IsOK(res1)) {
49193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49194 }
49195 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49196 {
49197 PyThreadState* __tstate = wxPyBeginAllowThreads();
49198 result = (int)(arg1)->GetProportion();
49199 wxPyEndAllowThreads(__tstate);
49200 if (PyErr_Occurred()) SWIG_fail;
49201 }
49202 resultobj = SWIG_From_int(static_cast< int >(result));
49203 return resultobj;
49204 fail:
49205 return NULL;
49206 }
49207
49208
49209 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49210 PyObject *resultobj = 0;
49211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49212 int arg2 ;
49213 void *argp1 = 0 ;
49214 int res1 = 0 ;
49215 int val2 ;
49216 int ecode2 = 0 ;
49217 PyObject * obj0 = 0 ;
49218 PyObject * obj1 = 0 ;
49219 char * kwnames[] = {
49220 (char *) "self",(char *) "flag", NULL
49221 };
49222
49223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49225 if (!SWIG_IsOK(res1)) {
49226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49227 }
49228 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49229 ecode2 = SWIG_AsVal_int(obj1, &val2);
49230 if (!SWIG_IsOK(ecode2)) {
49231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49232 }
49233 arg2 = static_cast< int >(val2);
49234 {
49235 PyThreadState* __tstate = wxPyBeginAllowThreads();
49236 (arg1)->SetFlag(arg2);
49237 wxPyEndAllowThreads(__tstate);
49238 if (PyErr_Occurred()) SWIG_fail;
49239 }
49240 resultobj = SWIG_Py_Void();
49241 return resultobj;
49242 fail:
49243 return NULL;
49244 }
49245
49246
49247 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49248 PyObject *resultobj = 0;
49249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49250 int result;
49251 void *argp1 = 0 ;
49252 int res1 = 0 ;
49253 PyObject *swig_obj[1] ;
49254
49255 if (!args) SWIG_fail;
49256 swig_obj[0] = args;
49257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49258 if (!SWIG_IsOK(res1)) {
49259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49260 }
49261 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49262 {
49263 PyThreadState* __tstate = wxPyBeginAllowThreads();
49264 result = (int)(arg1)->GetFlag();
49265 wxPyEndAllowThreads(__tstate);
49266 if (PyErr_Occurred()) SWIG_fail;
49267 }
49268 resultobj = SWIG_From_int(static_cast< int >(result));
49269 return resultobj;
49270 fail:
49271 return NULL;
49272 }
49273
49274
49275 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49276 PyObject *resultobj = 0;
49277 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49278 int arg2 ;
49279 void *argp1 = 0 ;
49280 int res1 = 0 ;
49281 int val2 ;
49282 int ecode2 = 0 ;
49283 PyObject * obj0 = 0 ;
49284 PyObject * obj1 = 0 ;
49285 char * kwnames[] = {
49286 (char *) "self",(char *) "border", NULL
49287 };
49288
49289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49291 if (!SWIG_IsOK(res1)) {
49292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49293 }
49294 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49295 ecode2 = SWIG_AsVal_int(obj1, &val2);
49296 if (!SWIG_IsOK(ecode2)) {
49297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49298 }
49299 arg2 = static_cast< int >(val2);
49300 {
49301 PyThreadState* __tstate = wxPyBeginAllowThreads();
49302 (arg1)->SetBorder(arg2);
49303 wxPyEndAllowThreads(__tstate);
49304 if (PyErr_Occurred()) SWIG_fail;
49305 }
49306 resultobj = SWIG_Py_Void();
49307 return resultobj;
49308 fail:
49309 return NULL;
49310 }
49311
49312
49313 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49314 PyObject *resultobj = 0;
49315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49316 int result;
49317 void *argp1 = 0 ;
49318 int res1 = 0 ;
49319 PyObject *swig_obj[1] ;
49320
49321 if (!args) SWIG_fail;
49322 swig_obj[0] = args;
49323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49324 if (!SWIG_IsOK(res1)) {
49325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49326 }
49327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 result = (int)(arg1)->GetBorder();
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_From_int(static_cast< int >(result));
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49344 wxWindow *result = 0 ;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49354 }
49355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (wxWindow *)(arg1)->GetWindow();
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 {
49363 resultobj = wxPyMake_wxObject(result, 0);
49364 }
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49372 PyObject *resultobj = 0;
49373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49374 wxWindow *arg2 = (wxWindow *) 0 ;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 void *argp2 = 0 ;
49378 int res2 = 0 ;
49379 PyObject * obj0 = 0 ;
49380 PyObject * obj1 = 0 ;
49381 char * kwnames[] = {
49382 (char *) "self",(char *) "window", NULL
49383 };
49384
49385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49387 if (!SWIG_IsOK(res1)) {
49388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49389 }
49390 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49392 if (!SWIG_IsOK(res2)) {
49393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49394 }
49395 arg2 = reinterpret_cast< wxWindow * >(argp2);
49396 {
49397 PyThreadState* __tstate = wxPyBeginAllowThreads();
49398 (arg1)->SetWindow(arg2);
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 resultobj = SWIG_Py_Void();
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49410 PyObject *resultobj = 0;
49411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49412 wxSizer *result = 0 ;
49413 void *argp1 = 0 ;
49414 int res1 = 0 ;
49415 PyObject *swig_obj[1] ;
49416
49417 if (!args) SWIG_fail;
49418 swig_obj[0] = args;
49419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49420 if (!SWIG_IsOK(res1)) {
49421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49422 }
49423 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49424 {
49425 PyThreadState* __tstate = wxPyBeginAllowThreads();
49426 result = (wxSizer *)(arg1)->GetSizer();
49427 wxPyEndAllowThreads(__tstate);
49428 if (PyErr_Occurred()) SWIG_fail;
49429 }
49430 {
49431 resultobj = wxPyMake_wxObject(result, (bool)0);
49432 }
49433 return resultobj;
49434 fail:
49435 return NULL;
49436 }
49437
49438
49439 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49440 PyObject *resultobj = 0;
49441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49442 wxSizer *arg2 = (wxSizer *) 0 ;
49443 void *argp1 = 0 ;
49444 int res1 = 0 ;
49445 int res2 = 0 ;
49446 PyObject * obj0 = 0 ;
49447 PyObject * obj1 = 0 ;
49448 char * kwnames[] = {
49449 (char *) "self",(char *) "sizer", NULL
49450 };
49451
49452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49454 if (!SWIG_IsOK(res1)) {
49455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49456 }
49457 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49458 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49459 if (!SWIG_IsOK(res2)) {
49460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49461 }
49462 {
49463 PyThreadState* __tstate = wxPyBeginAllowThreads();
49464 (arg1)->SetSizer(arg2);
49465 wxPyEndAllowThreads(__tstate);
49466 if (PyErr_Occurred()) SWIG_fail;
49467 }
49468 resultobj = SWIG_Py_Void();
49469 return resultobj;
49470 fail:
49471 return NULL;
49472 }
49473
49474
49475 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49476 PyObject *resultobj = 0;
49477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49478 wxSize result;
49479 void *argp1 = 0 ;
49480 int res1 = 0 ;
49481 PyObject *swig_obj[1] ;
49482
49483 if (!args) SWIG_fail;
49484 swig_obj[0] = args;
49485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49486 if (!SWIG_IsOK(res1)) {
49487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49488 }
49489 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49490 {
49491 PyThreadState* __tstate = wxPyBeginAllowThreads();
49492 result = (arg1)->GetSpacer();
49493 wxPyEndAllowThreads(__tstate);
49494 if (PyErr_Occurred()) SWIG_fail;
49495 }
49496 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49497 return resultobj;
49498 fail:
49499 return NULL;
49500 }
49501
49502
49503 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49504 PyObject *resultobj = 0;
49505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49506 wxSize *arg2 = 0 ;
49507 void *argp1 = 0 ;
49508 int res1 = 0 ;
49509 wxSize temp2 ;
49510 PyObject * obj0 = 0 ;
49511 PyObject * obj1 = 0 ;
49512 char * kwnames[] = {
49513 (char *) "self",(char *) "size", NULL
49514 };
49515
49516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49518 if (!SWIG_IsOK(res1)) {
49519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49520 }
49521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49522 {
49523 arg2 = &temp2;
49524 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49525 }
49526 {
49527 PyThreadState* __tstate = wxPyBeginAllowThreads();
49528 (arg1)->SetSpacer((wxSize const &)*arg2);
49529 wxPyEndAllowThreads(__tstate);
49530 if (PyErr_Occurred()) SWIG_fail;
49531 }
49532 resultobj = SWIG_Py_Void();
49533 return resultobj;
49534 fail:
49535 return NULL;
49536 }
49537
49538
49539 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49540 PyObject *resultobj = 0;
49541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49542 bool arg2 ;
49543 void *argp1 = 0 ;
49544 int res1 = 0 ;
49545 bool val2 ;
49546 int ecode2 = 0 ;
49547 PyObject * obj0 = 0 ;
49548 PyObject * obj1 = 0 ;
49549 char * kwnames[] = {
49550 (char *) "self",(char *) "show", NULL
49551 };
49552
49553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49555 if (!SWIG_IsOK(res1)) {
49556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49557 }
49558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49560 if (!SWIG_IsOK(ecode2)) {
49561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49562 }
49563 arg2 = static_cast< bool >(val2);
49564 {
49565 PyThreadState* __tstate = wxPyBeginAllowThreads();
49566 (arg1)->Show(arg2);
49567 wxPyEndAllowThreads(__tstate);
49568 if (PyErr_Occurred()) SWIG_fail;
49569 }
49570 resultobj = SWIG_Py_Void();
49571 return resultobj;
49572 fail:
49573 return NULL;
49574 }
49575
49576
49577 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49578 PyObject *resultobj = 0;
49579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49580 bool result;
49581 void *argp1 = 0 ;
49582 int res1 = 0 ;
49583 PyObject *swig_obj[1] ;
49584
49585 if (!args) SWIG_fail;
49586 swig_obj[0] = args;
49587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49588 if (!SWIG_IsOK(res1)) {
49589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49590 }
49591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49592 {
49593 PyThreadState* __tstate = wxPyBeginAllowThreads();
49594 result = (bool)(arg1)->IsShown();
49595 wxPyEndAllowThreads(__tstate);
49596 if (PyErr_Occurred()) SWIG_fail;
49597 }
49598 {
49599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49600 }
49601 return resultobj;
49602 fail:
49603 return NULL;
49604 }
49605
49606
49607 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49608 PyObject *resultobj = 0;
49609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49610 wxPoint result;
49611 void *argp1 = 0 ;
49612 int res1 = 0 ;
49613 PyObject *swig_obj[1] ;
49614
49615 if (!args) SWIG_fail;
49616 swig_obj[0] = args;
49617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49618 if (!SWIG_IsOK(res1)) {
49619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49620 }
49621 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 result = (arg1)->GetPosition();
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 PyObject *resultobj = 0;
49637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49638 PyObject *result = 0 ;
49639 void *argp1 = 0 ;
49640 int res1 = 0 ;
49641 PyObject *swig_obj[1] ;
49642
49643 if (!args) SWIG_fail;
49644 swig_obj[0] = args;
49645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49646 if (!SWIG_IsOK(res1)) {
49647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49648 }
49649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 resultobj = result;
49657 return resultobj;
49658 fail:
49659 return NULL;
49660 }
49661
49662
49663 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49664 PyObject *resultobj = 0;
49665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49666 PyObject *arg2 = (PyObject *) 0 ;
49667 void *argp1 = 0 ;
49668 int res1 = 0 ;
49669 PyObject * obj0 = 0 ;
49670 PyObject * obj1 = 0 ;
49671 char * kwnames[] = {
49672 (char *) "self",(char *) "userData", NULL
49673 };
49674
49675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49677 if (!SWIG_IsOK(res1)) {
49678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49679 }
49680 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49681 arg2 = obj1;
49682 {
49683 PyThreadState* __tstate = wxPyBeginAllowThreads();
49684 wxSizerItem_SetUserData(arg1,arg2);
49685 wxPyEndAllowThreads(__tstate);
49686 if (PyErr_Occurred()) SWIG_fail;
49687 }
49688 resultobj = SWIG_Py_Void();
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49696 PyObject *obj;
49697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49698 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49699 return SWIG_Py_Void();
49700 }
49701
49702 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49703 return SWIG_Python_InitShadowInstance(args);
49704 }
49705
49706 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49707 PyObject *resultobj = 0;
49708 wxSizer *arg1 = (wxSizer *) 0 ;
49709 void *argp1 = 0 ;
49710 int res1 = 0 ;
49711 PyObject *swig_obj[1] ;
49712
49713 if (!args) SWIG_fail;
49714 swig_obj[0] = args;
49715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49716 if (!SWIG_IsOK(res1)) {
49717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49718 }
49719 arg1 = reinterpret_cast< wxSizer * >(argp1);
49720 {
49721 PyThreadState* __tstate = wxPyBeginAllowThreads();
49722 delete arg1;
49723
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 resultobj = SWIG_Py_Void();
49728 return resultobj;
49729 fail:
49730 return NULL;
49731 }
49732
49733
49734 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49735 PyObject *resultobj = 0;
49736 wxSizer *arg1 = (wxSizer *) 0 ;
49737 PyObject *arg2 = (PyObject *) 0 ;
49738 void *argp1 = 0 ;
49739 int res1 = 0 ;
49740 PyObject * obj0 = 0 ;
49741 PyObject * obj1 = 0 ;
49742 char * kwnames[] = {
49743 (char *) "self",(char *) "_self", NULL
49744 };
49745
49746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49750 }
49751 arg1 = reinterpret_cast< wxSizer * >(argp1);
49752 arg2 = obj1;
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 wxSizer__setOORInfo(arg1,arg2);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49767 PyObject *resultobj = 0;
49768 wxSizer *arg1 = (wxSizer *) 0 ;
49769 PyObject *arg2 = (PyObject *) 0 ;
49770 int arg3 = (int) 0 ;
49771 int arg4 = (int) 0 ;
49772 int arg5 = (int) 0 ;
49773 PyObject *arg6 = (PyObject *) NULL ;
49774 wxSizerItem *result = 0 ;
49775 void *argp1 = 0 ;
49776 int res1 = 0 ;
49777 int val3 ;
49778 int ecode3 = 0 ;
49779 int val4 ;
49780 int ecode4 = 0 ;
49781 int val5 ;
49782 int ecode5 = 0 ;
49783 PyObject * obj0 = 0 ;
49784 PyObject * obj1 = 0 ;
49785 PyObject * obj2 = 0 ;
49786 PyObject * obj3 = 0 ;
49787 PyObject * obj4 = 0 ;
49788 PyObject * obj5 = 0 ;
49789 char * kwnames[] = {
49790 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49791 };
49792
49793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49795 if (!SWIG_IsOK(res1)) {
49796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49797 }
49798 arg1 = reinterpret_cast< wxSizer * >(argp1);
49799 arg2 = obj1;
49800 if (obj2) {
49801 ecode3 = SWIG_AsVal_int(obj2, &val3);
49802 if (!SWIG_IsOK(ecode3)) {
49803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49804 }
49805 arg3 = static_cast< int >(val3);
49806 }
49807 if (obj3) {
49808 ecode4 = SWIG_AsVal_int(obj3, &val4);
49809 if (!SWIG_IsOK(ecode4)) {
49810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49811 }
49812 arg4 = static_cast< int >(val4);
49813 }
49814 if (obj4) {
49815 ecode5 = SWIG_AsVal_int(obj4, &val5);
49816 if (!SWIG_IsOK(ecode5)) {
49817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49818 }
49819 arg5 = static_cast< int >(val5);
49820 }
49821 if (obj5) {
49822 arg6 = obj5;
49823 }
49824 {
49825 PyThreadState* __tstate = wxPyBeginAllowThreads();
49826 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49827 wxPyEndAllowThreads(__tstate);
49828 if (PyErr_Occurred()) SWIG_fail;
49829 }
49830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49831 return resultobj;
49832 fail:
49833 return NULL;
49834 }
49835
49836
49837 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49838 PyObject *resultobj = 0;
49839 wxSizer *arg1 = (wxSizer *) 0 ;
49840 int arg2 ;
49841 PyObject *arg3 = (PyObject *) 0 ;
49842 int arg4 = (int) 0 ;
49843 int arg5 = (int) 0 ;
49844 int arg6 = (int) 0 ;
49845 PyObject *arg7 = (PyObject *) NULL ;
49846 wxSizerItem *result = 0 ;
49847 void *argp1 = 0 ;
49848 int res1 = 0 ;
49849 int val2 ;
49850 int ecode2 = 0 ;
49851 int val4 ;
49852 int ecode4 = 0 ;
49853 int val5 ;
49854 int ecode5 = 0 ;
49855 int val6 ;
49856 int ecode6 = 0 ;
49857 PyObject * obj0 = 0 ;
49858 PyObject * obj1 = 0 ;
49859 PyObject * obj2 = 0 ;
49860 PyObject * obj3 = 0 ;
49861 PyObject * obj4 = 0 ;
49862 PyObject * obj5 = 0 ;
49863 PyObject * obj6 = 0 ;
49864 char * kwnames[] = {
49865 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49866 };
49867
49868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49870 if (!SWIG_IsOK(res1)) {
49871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49872 }
49873 arg1 = reinterpret_cast< wxSizer * >(argp1);
49874 ecode2 = SWIG_AsVal_int(obj1, &val2);
49875 if (!SWIG_IsOK(ecode2)) {
49876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49877 }
49878 arg2 = static_cast< int >(val2);
49879 arg3 = obj2;
49880 if (obj3) {
49881 ecode4 = SWIG_AsVal_int(obj3, &val4);
49882 if (!SWIG_IsOK(ecode4)) {
49883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49884 }
49885 arg4 = static_cast< int >(val4);
49886 }
49887 if (obj4) {
49888 ecode5 = SWIG_AsVal_int(obj4, &val5);
49889 if (!SWIG_IsOK(ecode5)) {
49890 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49891 }
49892 arg5 = static_cast< int >(val5);
49893 }
49894 if (obj5) {
49895 ecode6 = SWIG_AsVal_int(obj5, &val6);
49896 if (!SWIG_IsOK(ecode6)) {
49897 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49898 }
49899 arg6 = static_cast< int >(val6);
49900 }
49901 if (obj6) {
49902 arg7 = obj6;
49903 }
49904 {
49905 PyThreadState* __tstate = wxPyBeginAllowThreads();
49906 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49907 wxPyEndAllowThreads(__tstate);
49908 if (PyErr_Occurred()) SWIG_fail;
49909 }
49910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49911 return resultobj;
49912 fail:
49913 return NULL;
49914 }
49915
49916
49917 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49918 PyObject *resultobj = 0;
49919 wxSizer *arg1 = (wxSizer *) 0 ;
49920 PyObject *arg2 = (PyObject *) 0 ;
49921 int arg3 = (int) 0 ;
49922 int arg4 = (int) 0 ;
49923 int arg5 = (int) 0 ;
49924 PyObject *arg6 = (PyObject *) NULL ;
49925 wxSizerItem *result = 0 ;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 int val3 ;
49929 int ecode3 = 0 ;
49930 int val4 ;
49931 int ecode4 = 0 ;
49932 int val5 ;
49933 int ecode5 = 0 ;
49934 PyObject * obj0 = 0 ;
49935 PyObject * obj1 = 0 ;
49936 PyObject * obj2 = 0 ;
49937 PyObject * obj3 = 0 ;
49938 PyObject * obj4 = 0 ;
49939 PyObject * obj5 = 0 ;
49940 char * kwnames[] = {
49941 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49942 };
49943
49944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49946 if (!SWIG_IsOK(res1)) {
49947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49948 }
49949 arg1 = reinterpret_cast< wxSizer * >(argp1);
49950 arg2 = obj1;
49951 if (obj2) {
49952 ecode3 = SWIG_AsVal_int(obj2, &val3);
49953 if (!SWIG_IsOK(ecode3)) {
49954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49955 }
49956 arg3 = static_cast< int >(val3);
49957 }
49958 if (obj3) {
49959 ecode4 = SWIG_AsVal_int(obj3, &val4);
49960 if (!SWIG_IsOK(ecode4)) {
49961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49962 }
49963 arg4 = static_cast< int >(val4);
49964 }
49965 if (obj4) {
49966 ecode5 = SWIG_AsVal_int(obj4, &val5);
49967 if (!SWIG_IsOK(ecode5)) {
49968 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49969 }
49970 arg5 = static_cast< int >(val5);
49971 }
49972 if (obj5) {
49973 arg6 = obj5;
49974 }
49975 {
49976 PyThreadState* __tstate = wxPyBeginAllowThreads();
49977 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49978 wxPyEndAllowThreads(__tstate);
49979 if (PyErr_Occurred()) SWIG_fail;
49980 }
49981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49982 return resultobj;
49983 fail:
49984 return NULL;
49985 }
49986
49987
49988 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49989 PyObject *resultobj = 0;
49990 wxSizer *arg1 = (wxSizer *) 0 ;
49991 PyObject *arg2 = (PyObject *) 0 ;
49992 bool result;
49993 void *argp1 = 0 ;
49994 int res1 = 0 ;
49995 PyObject * obj0 = 0 ;
49996 PyObject * obj1 = 0 ;
49997 char * kwnames[] = {
49998 (char *) "self",(char *) "item", NULL
49999 };
50000
50001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50003 if (!SWIG_IsOK(res1)) {
50004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50005 }
50006 arg1 = reinterpret_cast< wxSizer * >(argp1);
50007 arg2 = obj1;
50008 {
50009 PyThreadState* __tstate = wxPyBeginAllowThreads();
50010 result = (bool)wxSizer_Remove(arg1,arg2);
50011 wxPyEndAllowThreads(__tstate);
50012 if (PyErr_Occurred()) SWIG_fail;
50013 }
50014 {
50015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50016 }
50017 return resultobj;
50018 fail:
50019 return NULL;
50020 }
50021
50022
50023 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50024 PyObject *resultobj = 0;
50025 wxSizer *arg1 = (wxSizer *) 0 ;
50026 PyObject *arg2 = (PyObject *) 0 ;
50027 bool result;
50028 void *argp1 = 0 ;
50029 int res1 = 0 ;
50030 PyObject * obj0 = 0 ;
50031 PyObject * obj1 = 0 ;
50032 char * kwnames[] = {
50033 (char *) "self",(char *) "item", NULL
50034 };
50035
50036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50038 if (!SWIG_IsOK(res1)) {
50039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50040 }
50041 arg1 = reinterpret_cast< wxSizer * >(argp1);
50042 arg2 = obj1;
50043 {
50044 PyThreadState* __tstate = wxPyBeginAllowThreads();
50045 result = (bool)wxSizer_Detach(arg1,arg2);
50046 wxPyEndAllowThreads(__tstate);
50047 if (PyErr_Occurred()) SWIG_fail;
50048 }
50049 {
50050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50051 }
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50059 PyObject *resultobj = 0;
50060 wxSizer *arg1 = (wxSizer *) 0 ;
50061 PyObject *arg2 = (PyObject *) 0 ;
50062 wxSizerItem *result = 0 ;
50063 void *argp1 = 0 ;
50064 int res1 = 0 ;
50065 PyObject * obj0 = 0 ;
50066 PyObject * obj1 = 0 ;
50067 char * kwnames[] = {
50068 (char *) "self",(char *) "item", NULL
50069 };
50070
50071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50073 if (!SWIG_IsOK(res1)) {
50074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50075 }
50076 arg1 = reinterpret_cast< wxSizer * >(argp1);
50077 arg2 = obj1;
50078 {
50079 PyThreadState* __tstate = wxPyBeginAllowThreads();
50080 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50081 wxPyEndAllowThreads(__tstate);
50082 if (PyErr_Occurred()) SWIG_fail;
50083 }
50084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50085 return resultobj;
50086 fail:
50087 return NULL;
50088 }
50089
50090
50091 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50092 PyObject *resultobj = 0;
50093 wxSizer *arg1 = (wxSizer *) 0 ;
50094 PyObject *arg2 = (PyObject *) 0 ;
50095 wxSize *arg3 = 0 ;
50096 void *argp1 = 0 ;
50097 int res1 = 0 ;
50098 wxSize temp3 ;
50099 PyObject * obj0 = 0 ;
50100 PyObject * obj1 = 0 ;
50101 PyObject * obj2 = 0 ;
50102 char * kwnames[] = {
50103 (char *) "self",(char *) "item",(char *) "size", NULL
50104 };
50105
50106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50108 if (!SWIG_IsOK(res1)) {
50109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50110 }
50111 arg1 = reinterpret_cast< wxSizer * >(argp1);
50112 arg2 = obj1;
50113 {
50114 arg3 = &temp3;
50115 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50116 }
50117 {
50118 PyThreadState* __tstate = wxPyBeginAllowThreads();
50119 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50120 wxPyEndAllowThreads(__tstate);
50121 if (PyErr_Occurred()) SWIG_fail;
50122 }
50123 resultobj = SWIG_Py_Void();
50124 return resultobj;
50125 fail:
50126 return NULL;
50127 }
50128
50129
50130 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50131 PyObject *resultobj = 0;
50132 wxSizer *arg1 = (wxSizer *) 0 ;
50133 wxWindow *arg2 = (wxWindow *) 0 ;
50134 wxWindow *arg3 = (wxWindow *) 0 ;
50135 bool arg4 = (bool) false ;
50136 bool result;
50137 void *argp1 = 0 ;
50138 int res1 = 0 ;
50139 void *argp2 = 0 ;
50140 int res2 = 0 ;
50141 void *argp3 = 0 ;
50142 int res3 = 0 ;
50143 bool val4 ;
50144 int ecode4 = 0 ;
50145 PyObject * obj0 = 0 ;
50146 PyObject * obj1 = 0 ;
50147 PyObject * obj2 = 0 ;
50148 PyObject * obj3 = 0 ;
50149 char * kwnames[] = {
50150 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50151 };
50152
50153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50155 if (!SWIG_IsOK(res1)) {
50156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50157 }
50158 arg1 = reinterpret_cast< wxSizer * >(argp1);
50159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50160 if (!SWIG_IsOK(res2)) {
50161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50162 }
50163 arg2 = reinterpret_cast< wxWindow * >(argp2);
50164 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50165 if (!SWIG_IsOK(res3)) {
50166 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50167 }
50168 arg3 = reinterpret_cast< wxWindow * >(argp3);
50169 if (obj3) {
50170 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50171 if (!SWIG_IsOK(ecode4)) {
50172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50173 }
50174 arg4 = static_cast< bool >(val4);
50175 }
50176 {
50177 PyThreadState* __tstate = wxPyBeginAllowThreads();
50178 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50179 wxPyEndAllowThreads(__tstate);
50180 if (PyErr_Occurred()) SWIG_fail;
50181 }
50182 {
50183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50184 }
50185 return resultobj;
50186 fail:
50187 return NULL;
50188 }
50189
50190
50191 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50192 PyObject *resultobj = 0;
50193 wxSizer *arg1 = (wxSizer *) 0 ;
50194 wxSizer *arg2 = (wxSizer *) 0 ;
50195 wxSizer *arg3 = (wxSizer *) 0 ;
50196 bool arg4 = (bool) false ;
50197 bool result;
50198 void *argp1 = 0 ;
50199 int res1 = 0 ;
50200 void *argp2 = 0 ;
50201 int res2 = 0 ;
50202 void *argp3 = 0 ;
50203 int res3 = 0 ;
50204 bool val4 ;
50205 int ecode4 = 0 ;
50206 PyObject * obj0 = 0 ;
50207 PyObject * obj1 = 0 ;
50208 PyObject * obj2 = 0 ;
50209 PyObject * obj3 = 0 ;
50210 char * kwnames[] = {
50211 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50212 };
50213
50214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50216 if (!SWIG_IsOK(res1)) {
50217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50218 }
50219 arg1 = reinterpret_cast< wxSizer * >(argp1);
50220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50221 if (!SWIG_IsOK(res2)) {
50222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50223 }
50224 arg2 = reinterpret_cast< wxSizer * >(argp2);
50225 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50226 if (!SWIG_IsOK(res3)) {
50227 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50228 }
50229 arg3 = reinterpret_cast< wxSizer * >(argp3);
50230 if (obj3) {
50231 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50232 if (!SWIG_IsOK(ecode4)) {
50233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50234 }
50235 arg4 = static_cast< bool >(val4);
50236 }
50237 {
50238 PyThreadState* __tstate = wxPyBeginAllowThreads();
50239 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50240 wxPyEndAllowThreads(__tstate);
50241 if (PyErr_Occurred()) SWIG_fail;
50242 }
50243 {
50244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50245 }
50246 return resultobj;
50247 fail:
50248 return NULL;
50249 }
50250
50251
50252 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50253 PyObject *resultobj = 0;
50254 wxSizer *arg1 = (wxSizer *) 0 ;
50255 size_t arg2 ;
50256 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50257 bool result;
50258 void *argp1 = 0 ;
50259 int res1 = 0 ;
50260 size_t val2 ;
50261 int ecode2 = 0 ;
50262 void *argp3 = 0 ;
50263 int res3 = 0 ;
50264 PyObject * obj0 = 0 ;
50265 PyObject * obj1 = 0 ;
50266 PyObject * obj2 = 0 ;
50267 char * kwnames[] = {
50268 (char *) "self",(char *) "index",(char *) "newitem", NULL
50269 };
50270
50271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50273 if (!SWIG_IsOK(res1)) {
50274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50275 }
50276 arg1 = reinterpret_cast< wxSizer * >(argp1);
50277 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50278 if (!SWIG_IsOK(ecode2)) {
50279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50280 }
50281 arg2 = static_cast< size_t >(val2);
50282 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50283 if (!SWIG_IsOK(res3)) {
50284 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50285 }
50286 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50287 {
50288 PyThreadState* __tstate = wxPyBeginAllowThreads();
50289 result = (bool)(arg1)->Replace(arg2,arg3);
50290 wxPyEndAllowThreads(__tstate);
50291 if (PyErr_Occurred()) SWIG_fail;
50292 }
50293 {
50294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50295 }
50296 return resultobj;
50297 fail:
50298 return NULL;
50299 }
50300
50301
50302 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50303 PyObject *resultobj = 0;
50304 wxSizer *arg1 = (wxSizer *) 0 ;
50305 wxWindow *arg2 = (wxWindow *) 0 ;
50306 void *argp1 = 0 ;
50307 int res1 = 0 ;
50308 void *argp2 = 0 ;
50309 int res2 = 0 ;
50310 PyObject * obj0 = 0 ;
50311 PyObject * obj1 = 0 ;
50312 char * kwnames[] = {
50313 (char *) "self",(char *) "window", NULL
50314 };
50315
50316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50318 if (!SWIG_IsOK(res1)) {
50319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50320 }
50321 arg1 = reinterpret_cast< wxSizer * >(argp1);
50322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50323 if (!SWIG_IsOK(res2)) {
50324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50325 }
50326 arg2 = reinterpret_cast< wxWindow * >(argp2);
50327 {
50328 PyThreadState* __tstate = wxPyBeginAllowThreads();
50329 (arg1)->SetContainingWindow(arg2);
50330 wxPyEndAllowThreads(__tstate);
50331 if (PyErr_Occurred()) SWIG_fail;
50332 }
50333 resultobj = SWIG_Py_Void();
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50341 PyObject *resultobj = 0;
50342 wxSizer *arg1 = (wxSizer *) 0 ;
50343 wxWindow *result = 0 ;
50344 void *argp1 = 0 ;
50345 int res1 = 0 ;
50346 PyObject *swig_obj[1] ;
50347
50348 if (!args) SWIG_fail;
50349 swig_obj[0] = args;
50350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50351 if (!SWIG_IsOK(res1)) {
50352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50353 }
50354 arg1 = reinterpret_cast< wxSizer * >(argp1);
50355 {
50356 PyThreadState* __tstate = wxPyBeginAllowThreads();
50357 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50358 wxPyEndAllowThreads(__tstate);
50359 if (PyErr_Occurred()) SWIG_fail;
50360 }
50361 {
50362 resultobj = wxPyMake_wxObject(result, 0);
50363 }
50364 return resultobj;
50365 fail:
50366 return NULL;
50367 }
50368
50369
50370 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50371 PyObject *resultobj = 0;
50372 wxSizer *arg1 = (wxSizer *) 0 ;
50373 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50374 wxSizerItem *result = 0 ;
50375 void *argp1 = 0 ;
50376 int res1 = 0 ;
50377 int res2 = 0 ;
50378 PyObject * obj0 = 0 ;
50379 PyObject * obj1 = 0 ;
50380 char * kwnames[] = {
50381 (char *) "self",(char *) "item", NULL
50382 };
50383
50384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50386 if (!SWIG_IsOK(res1)) {
50387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50388 }
50389 arg1 = reinterpret_cast< wxSizer * >(argp1);
50390 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50391 if (!SWIG_IsOK(res2)) {
50392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50393 }
50394 {
50395 PyThreadState* __tstate = wxPyBeginAllowThreads();
50396 result = (wxSizerItem *)(arg1)->Add(arg2);
50397 wxPyEndAllowThreads(__tstate);
50398 if (PyErr_Occurred()) SWIG_fail;
50399 }
50400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50401 return resultobj;
50402 fail:
50403 return NULL;
50404 }
50405
50406
50407 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50408 PyObject *resultobj = 0;
50409 wxSizer *arg1 = (wxSizer *) 0 ;
50410 size_t arg2 ;
50411 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50412 wxSizerItem *result = 0 ;
50413 void *argp1 = 0 ;
50414 int res1 = 0 ;
50415 size_t val2 ;
50416 int ecode2 = 0 ;
50417 int res3 = 0 ;
50418 PyObject * obj0 = 0 ;
50419 PyObject * obj1 = 0 ;
50420 PyObject * obj2 = 0 ;
50421 char * kwnames[] = {
50422 (char *) "self",(char *) "index",(char *) "item", NULL
50423 };
50424
50425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50427 if (!SWIG_IsOK(res1)) {
50428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50429 }
50430 arg1 = reinterpret_cast< wxSizer * >(argp1);
50431 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50432 if (!SWIG_IsOK(ecode2)) {
50433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50434 }
50435 arg2 = static_cast< size_t >(val2);
50436 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50437 if (!SWIG_IsOK(res3)) {
50438 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50439 }
50440 {
50441 PyThreadState* __tstate = wxPyBeginAllowThreads();
50442 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50443 wxPyEndAllowThreads(__tstate);
50444 if (PyErr_Occurred()) SWIG_fail;
50445 }
50446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50447 return resultobj;
50448 fail:
50449 return NULL;
50450 }
50451
50452
50453 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50454 PyObject *resultobj = 0;
50455 wxSizer *arg1 = (wxSizer *) 0 ;
50456 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50457 wxSizerItem *result = 0 ;
50458 void *argp1 = 0 ;
50459 int res1 = 0 ;
50460 int res2 = 0 ;
50461 PyObject * obj0 = 0 ;
50462 PyObject * obj1 = 0 ;
50463 char * kwnames[] = {
50464 (char *) "self",(char *) "item", NULL
50465 };
50466
50467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50469 if (!SWIG_IsOK(res1)) {
50470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50471 }
50472 arg1 = reinterpret_cast< wxSizer * >(argp1);
50473 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50474 if (!SWIG_IsOK(res2)) {
50475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50476 }
50477 {
50478 PyThreadState* __tstate = wxPyBeginAllowThreads();
50479 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50480 wxPyEndAllowThreads(__tstate);
50481 if (PyErr_Occurred()) SWIG_fail;
50482 }
50483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50484 return resultobj;
50485 fail:
50486 return NULL;
50487 }
50488
50489
50490 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50491 PyObject *resultobj = 0;
50492 wxSizer *arg1 = (wxSizer *) 0 ;
50493 int arg2 ;
50494 int arg3 ;
50495 int arg4 ;
50496 int arg5 ;
50497 void *argp1 = 0 ;
50498 int res1 = 0 ;
50499 int val2 ;
50500 int ecode2 = 0 ;
50501 int val3 ;
50502 int ecode3 = 0 ;
50503 int val4 ;
50504 int ecode4 = 0 ;
50505 int val5 ;
50506 int ecode5 = 0 ;
50507 PyObject * obj0 = 0 ;
50508 PyObject * obj1 = 0 ;
50509 PyObject * obj2 = 0 ;
50510 PyObject * obj3 = 0 ;
50511 PyObject * obj4 = 0 ;
50512 char * kwnames[] = {
50513 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50514 };
50515
50516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50518 if (!SWIG_IsOK(res1)) {
50519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50520 }
50521 arg1 = reinterpret_cast< wxSizer * >(argp1);
50522 ecode2 = SWIG_AsVal_int(obj1, &val2);
50523 if (!SWIG_IsOK(ecode2)) {
50524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50525 }
50526 arg2 = static_cast< int >(val2);
50527 ecode3 = SWIG_AsVal_int(obj2, &val3);
50528 if (!SWIG_IsOK(ecode3)) {
50529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50530 }
50531 arg3 = static_cast< int >(val3);
50532 ecode4 = SWIG_AsVal_int(obj3, &val4);
50533 if (!SWIG_IsOK(ecode4)) {
50534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50535 }
50536 arg4 = static_cast< int >(val4);
50537 ecode5 = SWIG_AsVal_int(obj4, &val5);
50538 if (!SWIG_IsOK(ecode5)) {
50539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50540 }
50541 arg5 = static_cast< int >(val5);
50542 {
50543 PyThreadState* __tstate = wxPyBeginAllowThreads();
50544 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50545 wxPyEndAllowThreads(__tstate);
50546 if (PyErr_Occurred()) SWIG_fail;
50547 }
50548 resultobj = SWIG_Py_Void();
50549 return resultobj;
50550 fail:
50551 return NULL;
50552 }
50553
50554
50555 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50556 PyObject *resultobj = 0;
50557 wxSizer *arg1 = (wxSizer *) 0 ;
50558 wxSize *arg2 = 0 ;
50559 void *argp1 = 0 ;
50560 int res1 = 0 ;
50561 wxSize temp2 ;
50562 PyObject * obj0 = 0 ;
50563 PyObject * obj1 = 0 ;
50564 char * kwnames[] = {
50565 (char *) "self",(char *) "size", NULL
50566 };
50567
50568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50570 if (!SWIG_IsOK(res1)) {
50571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50572 }
50573 arg1 = reinterpret_cast< wxSizer * >(argp1);
50574 {
50575 arg2 = &temp2;
50576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50577 }
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 (arg1)->SetMinSize((wxSize const &)*arg2);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = SWIG_Py_Void();
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50592 PyObject *resultobj = 0;
50593 wxSizer *arg1 = (wxSizer *) 0 ;
50594 wxSize result;
50595 void *argp1 = 0 ;
50596 int res1 = 0 ;
50597 PyObject *swig_obj[1] ;
50598
50599 if (!args) SWIG_fail;
50600 swig_obj[0] = args;
50601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxSizer * >(argp1);
50606 {
50607 PyThreadState* __tstate = wxPyBeginAllowThreads();
50608 result = (arg1)->GetSize();
50609 wxPyEndAllowThreads(__tstate);
50610 if (PyErr_Occurred()) SWIG_fail;
50611 }
50612 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50613 return resultobj;
50614 fail:
50615 return NULL;
50616 }
50617
50618
50619 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50620 PyObject *resultobj = 0;
50621 wxSizer *arg1 = (wxSizer *) 0 ;
50622 wxPoint result;
50623 void *argp1 = 0 ;
50624 int res1 = 0 ;
50625 PyObject *swig_obj[1] ;
50626
50627 if (!args) SWIG_fail;
50628 swig_obj[0] = args;
50629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50630 if (!SWIG_IsOK(res1)) {
50631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50632 }
50633 arg1 = reinterpret_cast< wxSizer * >(argp1);
50634 {
50635 PyThreadState* __tstate = wxPyBeginAllowThreads();
50636 result = (arg1)->GetPosition();
50637 wxPyEndAllowThreads(__tstate);
50638 if (PyErr_Occurred()) SWIG_fail;
50639 }
50640 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50641 return resultobj;
50642 fail:
50643 return NULL;
50644 }
50645
50646
50647 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50648 PyObject *resultobj = 0;
50649 wxSizer *arg1 = (wxSizer *) 0 ;
50650 wxSize result;
50651 void *argp1 = 0 ;
50652 int res1 = 0 ;
50653 PyObject *swig_obj[1] ;
50654
50655 if (!args) SWIG_fail;
50656 swig_obj[0] = args;
50657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50658 if (!SWIG_IsOK(res1)) {
50659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50660 }
50661 arg1 = reinterpret_cast< wxSizer * >(argp1);
50662 {
50663 PyThreadState* __tstate = wxPyBeginAllowThreads();
50664 result = (arg1)->GetMinSize();
50665 wxPyEndAllowThreads(__tstate);
50666 if (PyErr_Occurred()) SWIG_fail;
50667 }
50668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50669 return resultobj;
50670 fail:
50671 return NULL;
50672 }
50673
50674
50675 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50676 PyObject *resultobj = 0;
50677 wxSizer *arg1 = (wxSizer *) 0 ;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 PyObject *swig_obj[1] ;
50681
50682 if (!args) SWIG_fail;
50683 swig_obj[0] = args;
50684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50685 if (!SWIG_IsOK(res1)) {
50686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50687 }
50688 arg1 = reinterpret_cast< wxSizer * >(argp1);
50689 {
50690 PyThreadState* __tstate = wxPyBeginAllowThreads();
50691 (arg1)->RecalcSizes();
50692 wxPyEndAllowThreads(__tstate);
50693 if (PyErr_Occurred()) SWIG_fail;
50694 }
50695 resultobj = SWIG_Py_Void();
50696 return resultobj;
50697 fail:
50698 return NULL;
50699 }
50700
50701
50702 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50703 PyObject *resultobj = 0;
50704 wxSizer *arg1 = (wxSizer *) 0 ;
50705 wxSize result;
50706 void *argp1 = 0 ;
50707 int res1 = 0 ;
50708 PyObject *swig_obj[1] ;
50709
50710 if (!args) SWIG_fail;
50711 swig_obj[0] = args;
50712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50713 if (!SWIG_IsOK(res1)) {
50714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50715 }
50716 arg1 = reinterpret_cast< wxSizer * >(argp1);
50717 {
50718 PyThreadState* __tstate = wxPyBeginAllowThreads();
50719 result = (arg1)->CalcMin();
50720 wxPyEndAllowThreads(__tstate);
50721 if (PyErr_Occurred()) SWIG_fail;
50722 }
50723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50724 return resultobj;
50725 fail:
50726 return NULL;
50727 }
50728
50729
50730 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50731 PyObject *resultobj = 0;
50732 wxSizer *arg1 = (wxSizer *) 0 ;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 PyObject *swig_obj[1] ;
50736
50737 if (!args) SWIG_fail;
50738 swig_obj[0] = args;
50739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50740 if (!SWIG_IsOK(res1)) {
50741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50742 }
50743 arg1 = reinterpret_cast< wxSizer * >(argp1);
50744 {
50745 PyThreadState* __tstate = wxPyBeginAllowThreads();
50746 (arg1)->Layout();
50747 wxPyEndAllowThreads(__tstate);
50748 if (PyErr_Occurred()) SWIG_fail;
50749 }
50750 resultobj = SWIG_Py_Void();
50751 return resultobj;
50752 fail:
50753 return NULL;
50754 }
50755
50756
50757 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50758 PyObject *resultobj = 0;
50759 wxSizer *arg1 = (wxSizer *) 0 ;
50760 wxWindow *arg2 = (wxWindow *) 0 ;
50761 wxSize result;
50762 void *argp1 = 0 ;
50763 int res1 = 0 ;
50764 void *argp2 = 0 ;
50765 int res2 = 0 ;
50766 PyObject * obj0 = 0 ;
50767 PyObject * obj1 = 0 ;
50768 char * kwnames[] = {
50769 (char *) "self",(char *) "window", NULL
50770 };
50771
50772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50774 if (!SWIG_IsOK(res1)) {
50775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50776 }
50777 arg1 = reinterpret_cast< wxSizer * >(argp1);
50778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50779 if (!SWIG_IsOK(res2)) {
50780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50781 }
50782 arg2 = reinterpret_cast< wxWindow * >(argp2);
50783 {
50784 PyThreadState* __tstate = wxPyBeginAllowThreads();
50785 result = (arg1)->Fit(arg2);
50786 wxPyEndAllowThreads(__tstate);
50787 if (PyErr_Occurred()) SWIG_fail;
50788 }
50789 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50790 return resultobj;
50791 fail:
50792 return NULL;
50793 }
50794
50795
50796 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50797 PyObject *resultobj = 0;
50798 wxSizer *arg1 = (wxSizer *) 0 ;
50799 wxWindow *arg2 = (wxWindow *) 0 ;
50800 void *argp1 = 0 ;
50801 int res1 = 0 ;
50802 void *argp2 = 0 ;
50803 int res2 = 0 ;
50804 PyObject * obj0 = 0 ;
50805 PyObject * obj1 = 0 ;
50806 char * kwnames[] = {
50807 (char *) "self",(char *) "window", NULL
50808 };
50809
50810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50812 if (!SWIG_IsOK(res1)) {
50813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50814 }
50815 arg1 = reinterpret_cast< wxSizer * >(argp1);
50816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50817 if (!SWIG_IsOK(res2)) {
50818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50819 }
50820 arg2 = reinterpret_cast< wxWindow * >(argp2);
50821 {
50822 PyThreadState* __tstate = wxPyBeginAllowThreads();
50823 (arg1)->FitInside(arg2);
50824 wxPyEndAllowThreads(__tstate);
50825 if (PyErr_Occurred()) SWIG_fail;
50826 }
50827 resultobj = SWIG_Py_Void();
50828 return resultobj;
50829 fail:
50830 return NULL;
50831 }
50832
50833
50834 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50835 PyObject *resultobj = 0;
50836 wxSizer *arg1 = (wxSizer *) 0 ;
50837 wxWindow *arg2 = (wxWindow *) 0 ;
50838 void *argp1 = 0 ;
50839 int res1 = 0 ;
50840 void *argp2 = 0 ;
50841 int res2 = 0 ;
50842 PyObject * obj0 = 0 ;
50843 PyObject * obj1 = 0 ;
50844 char * kwnames[] = {
50845 (char *) "self",(char *) "window", NULL
50846 };
50847
50848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50850 if (!SWIG_IsOK(res1)) {
50851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50852 }
50853 arg1 = reinterpret_cast< wxSizer * >(argp1);
50854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50855 if (!SWIG_IsOK(res2)) {
50856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50857 }
50858 arg2 = reinterpret_cast< wxWindow * >(argp2);
50859 {
50860 PyThreadState* __tstate = wxPyBeginAllowThreads();
50861 (arg1)->SetSizeHints(arg2);
50862 wxPyEndAllowThreads(__tstate);
50863 if (PyErr_Occurred()) SWIG_fail;
50864 }
50865 resultobj = SWIG_Py_Void();
50866 return resultobj;
50867 fail:
50868 return NULL;
50869 }
50870
50871
50872 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50873 PyObject *resultobj = 0;
50874 wxSizer *arg1 = (wxSizer *) 0 ;
50875 wxWindow *arg2 = (wxWindow *) 0 ;
50876 void *argp1 = 0 ;
50877 int res1 = 0 ;
50878 void *argp2 = 0 ;
50879 int res2 = 0 ;
50880 PyObject * obj0 = 0 ;
50881 PyObject * obj1 = 0 ;
50882 char * kwnames[] = {
50883 (char *) "self",(char *) "window", NULL
50884 };
50885
50886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50888 if (!SWIG_IsOK(res1)) {
50889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50890 }
50891 arg1 = reinterpret_cast< wxSizer * >(argp1);
50892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50893 if (!SWIG_IsOK(res2)) {
50894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50895 }
50896 arg2 = reinterpret_cast< wxWindow * >(argp2);
50897 {
50898 PyThreadState* __tstate = wxPyBeginAllowThreads();
50899 (arg1)->SetVirtualSizeHints(arg2);
50900 wxPyEndAllowThreads(__tstate);
50901 if (PyErr_Occurred()) SWIG_fail;
50902 }
50903 resultobj = SWIG_Py_Void();
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50911 PyObject *resultobj = 0;
50912 wxSizer *arg1 = (wxSizer *) 0 ;
50913 bool arg2 = (bool) false ;
50914 void *argp1 = 0 ;
50915 int res1 = 0 ;
50916 bool val2 ;
50917 int ecode2 = 0 ;
50918 PyObject * obj0 = 0 ;
50919 PyObject * obj1 = 0 ;
50920 char * kwnames[] = {
50921 (char *) "self",(char *) "deleteWindows", NULL
50922 };
50923
50924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50926 if (!SWIG_IsOK(res1)) {
50927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50928 }
50929 arg1 = reinterpret_cast< wxSizer * >(argp1);
50930 if (obj1) {
50931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50932 if (!SWIG_IsOK(ecode2)) {
50933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50934 }
50935 arg2 = static_cast< bool >(val2);
50936 }
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 (arg1)->Clear(arg2);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_Py_Void();
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50951 PyObject *resultobj = 0;
50952 wxSizer *arg1 = (wxSizer *) 0 ;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 PyObject *swig_obj[1] ;
50956
50957 if (!args) SWIG_fail;
50958 swig_obj[0] = args;
50959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50960 if (!SWIG_IsOK(res1)) {
50961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50962 }
50963 arg1 = reinterpret_cast< wxSizer * >(argp1);
50964 {
50965 PyThreadState* __tstate = wxPyBeginAllowThreads();
50966 (arg1)->DeleteWindows();
50967 wxPyEndAllowThreads(__tstate);
50968 if (PyErr_Occurred()) SWIG_fail;
50969 }
50970 resultobj = SWIG_Py_Void();
50971 return resultobj;
50972 fail:
50973 return NULL;
50974 }
50975
50976
50977 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50978 PyObject *resultobj = 0;
50979 wxSizer *arg1 = (wxSizer *) 0 ;
50980 PyObject *result = 0 ;
50981 void *argp1 = 0 ;
50982 int res1 = 0 ;
50983 PyObject *swig_obj[1] ;
50984
50985 if (!args) SWIG_fail;
50986 swig_obj[0] = args;
50987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50988 if (!SWIG_IsOK(res1)) {
50989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50990 }
50991 arg1 = reinterpret_cast< wxSizer * >(argp1);
50992 {
50993 PyThreadState* __tstate = wxPyBeginAllowThreads();
50994 result = (PyObject *)wxSizer_GetChildren(arg1);
50995 wxPyEndAllowThreads(__tstate);
50996 if (PyErr_Occurred()) SWIG_fail;
50997 }
50998 resultobj = result;
50999 return resultobj;
51000 fail:
51001 return NULL;
51002 }
51003
51004
51005 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51006 PyObject *resultobj = 0;
51007 wxSizer *arg1 = (wxSizer *) 0 ;
51008 PyObject *arg2 = (PyObject *) 0 ;
51009 bool arg3 = (bool) true ;
51010 bool arg4 = (bool) false ;
51011 bool result;
51012 void *argp1 = 0 ;
51013 int res1 = 0 ;
51014 bool val3 ;
51015 int ecode3 = 0 ;
51016 bool val4 ;
51017 int ecode4 = 0 ;
51018 PyObject * obj0 = 0 ;
51019 PyObject * obj1 = 0 ;
51020 PyObject * obj2 = 0 ;
51021 PyObject * obj3 = 0 ;
51022 char * kwnames[] = {
51023 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51024 };
51025
51026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51028 if (!SWIG_IsOK(res1)) {
51029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51030 }
51031 arg1 = reinterpret_cast< wxSizer * >(argp1);
51032 arg2 = obj1;
51033 if (obj2) {
51034 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51035 if (!SWIG_IsOK(ecode3)) {
51036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51037 }
51038 arg3 = static_cast< bool >(val3);
51039 }
51040 if (obj3) {
51041 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51042 if (!SWIG_IsOK(ecode4)) {
51043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51044 }
51045 arg4 = static_cast< bool >(val4);
51046 }
51047 {
51048 PyThreadState* __tstate = wxPyBeginAllowThreads();
51049 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51050 wxPyEndAllowThreads(__tstate);
51051 if (PyErr_Occurred()) SWIG_fail;
51052 }
51053 {
51054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51055 }
51056 return resultobj;
51057 fail:
51058 return NULL;
51059 }
51060
51061
51062 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51063 PyObject *resultobj = 0;
51064 wxSizer *arg1 = (wxSizer *) 0 ;
51065 PyObject *arg2 = (PyObject *) 0 ;
51066 bool result;
51067 void *argp1 = 0 ;
51068 int res1 = 0 ;
51069 PyObject * obj0 = 0 ;
51070 PyObject * obj1 = 0 ;
51071 char * kwnames[] = {
51072 (char *) "self",(char *) "item", NULL
51073 };
51074
51075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51077 if (!SWIG_IsOK(res1)) {
51078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51079 }
51080 arg1 = reinterpret_cast< wxSizer * >(argp1);
51081 arg2 = obj1;
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 result = (bool)wxSizer_IsShown(arg1,arg2);
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 {
51089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51090 }
51091 return resultobj;
51092 fail:
51093 return NULL;
51094 }
51095
51096
51097 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51098 PyObject *resultobj = 0;
51099 wxSizer *arg1 = (wxSizer *) 0 ;
51100 bool arg2 ;
51101 void *argp1 = 0 ;
51102 int res1 = 0 ;
51103 bool val2 ;
51104 int ecode2 = 0 ;
51105 PyObject * obj0 = 0 ;
51106 PyObject * obj1 = 0 ;
51107 char * kwnames[] = {
51108 (char *) "self",(char *) "show", NULL
51109 };
51110
51111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51113 if (!SWIG_IsOK(res1)) {
51114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51115 }
51116 arg1 = reinterpret_cast< wxSizer * >(argp1);
51117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51118 if (!SWIG_IsOK(ecode2)) {
51119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51120 }
51121 arg2 = static_cast< bool >(val2);
51122 {
51123 PyThreadState* __tstate = wxPyBeginAllowThreads();
51124 (arg1)->ShowItems(arg2);
51125 wxPyEndAllowThreads(__tstate);
51126 if (PyErr_Occurred()) SWIG_fail;
51127 }
51128 resultobj = SWIG_Py_Void();
51129 return resultobj;
51130 fail:
51131 return NULL;
51132 }
51133
51134
51135 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51136 PyObject *obj;
51137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51138 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51139 return SWIG_Py_Void();
51140 }
51141
51142 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51143 PyObject *resultobj = 0;
51144 wxPySizer *result = 0 ;
51145
51146 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51147 {
51148 PyThreadState* __tstate = wxPyBeginAllowThreads();
51149 result = (wxPySizer *)new wxPySizer();
51150 wxPyEndAllowThreads(__tstate);
51151 if (PyErr_Occurred()) SWIG_fail;
51152 }
51153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51154 return resultobj;
51155 fail:
51156 return NULL;
51157 }
51158
51159
51160 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51161 PyObject *resultobj = 0;
51162 wxPySizer *arg1 = (wxPySizer *) 0 ;
51163 PyObject *arg2 = (PyObject *) 0 ;
51164 PyObject *arg3 = (PyObject *) 0 ;
51165 void *argp1 = 0 ;
51166 int res1 = 0 ;
51167 PyObject * obj0 = 0 ;
51168 PyObject * obj1 = 0 ;
51169 PyObject * obj2 = 0 ;
51170 char * kwnames[] = {
51171 (char *) "self",(char *) "self",(char *) "_class", NULL
51172 };
51173
51174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51176 if (!SWIG_IsOK(res1)) {
51177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51178 }
51179 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51180 arg2 = obj1;
51181 arg3 = obj2;
51182 {
51183 PyThreadState* __tstate = wxPyBeginAllowThreads();
51184 (arg1)->_setCallbackInfo(arg2,arg3);
51185 wxPyEndAllowThreads(__tstate);
51186 if (PyErr_Occurred()) SWIG_fail;
51187 }
51188 resultobj = SWIG_Py_Void();
51189 return resultobj;
51190 fail:
51191 return NULL;
51192 }
51193
51194
51195 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51196 PyObject *obj;
51197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51198 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51199 return SWIG_Py_Void();
51200 }
51201
51202 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51203 return SWIG_Python_InitShadowInstance(args);
51204 }
51205
51206 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51207 PyObject *resultobj = 0;
51208 int arg1 = (int) wxHORIZONTAL ;
51209 wxBoxSizer *result = 0 ;
51210 int val1 ;
51211 int ecode1 = 0 ;
51212 PyObject * obj0 = 0 ;
51213 char * kwnames[] = {
51214 (char *) "orient", NULL
51215 };
51216
51217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51218 if (obj0) {
51219 ecode1 = SWIG_AsVal_int(obj0, &val1);
51220 if (!SWIG_IsOK(ecode1)) {
51221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51222 }
51223 arg1 = static_cast< int >(val1);
51224 }
51225 {
51226 PyThreadState* __tstate = wxPyBeginAllowThreads();
51227 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51228 wxPyEndAllowThreads(__tstate);
51229 if (PyErr_Occurred()) SWIG_fail;
51230 }
51231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51232 return resultobj;
51233 fail:
51234 return NULL;
51235 }
51236
51237
51238 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51239 PyObject *resultobj = 0;
51240 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51241 int result;
51242 void *argp1 = 0 ;
51243 int res1 = 0 ;
51244 PyObject *swig_obj[1] ;
51245
51246 if (!args) SWIG_fail;
51247 swig_obj[0] = args;
51248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51249 if (!SWIG_IsOK(res1)) {
51250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51251 }
51252 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51253 {
51254 PyThreadState* __tstate = wxPyBeginAllowThreads();
51255 result = (int)(arg1)->GetOrientation();
51256 wxPyEndAllowThreads(__tstate);
51257 if (PyErr_Occurred()) SWIG_fail;
51258 }
51259 resultobj = SWIG_From_int(static_cast< int >(result));
51260 return resultobj;
51261 fail:
51262 return NULL;
51263 }
51264
51265
51266 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51267 PyObject *resultobj = 0;
51268 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51269 int arg2 ;
51270 void *argp1 = 0 ;
51271 int res1 = 0 ;
51272 int val2 ;
51273 int ecode2 = 0 ;
51274 PyObject * obj0 = 0 ;
51275 PyObject * obj1 = 0 ;
51276 char * kwnames[] = {
51277 (char *) "self",(char *) "orient", NULL
51278 };
51279
51280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51282 if (!SWIG_IsOK(res1)) {
51283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51284 }
51285 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51286 ecode2 = SWIG_AsVal_int(obj1, &val2);
51287 if (!SWIG_IsOK(ecode2)) {
51288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51289 }
51290 arg2 = static_cast< int >(val2);
51291 {
51292 PyThreadState* __tstate = wxPyBeginAllowThreads();
51293 (arg1)->SetOrientation(arg2);
51294 wxPyEndAllowThreads(__tstate);
51295 if (PyErr_Occurred()) SWIG_fail;
51296 }
51297 resultobj = SWIG_Py_Void();
51298 return resultobj;
51299 fail:
51300 return NULL;
51301 }
51302
51303
51304 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51305 PyObject *obj;
51306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51307 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51308 return SWIG_Py_Void();
51309 }
51310
51311 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51312 return SWIG_Python_InitShadowInstance(args);
51313 }
51314
51315 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51316 PyObject *resultobj = 0;
51317 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51318 int arg2 = (int) wxHORIZONTAL ;
51319 wxStaticBoxSizer *result = 0 ;
51320 void *argp1 = 0 ;
51321 int res1 = 0 ;
51322 int val2 ;
51323 int ecode2 = 0 ;
51324 PyObject * obj0 = 0 ;
51325 PyObject * obj1 = 0 ;
51326 char * kwnames[] = {
51327 (char *) "box",(char *) "orient", NULL
51328 };
51329
51330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51334 }
51335 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51336 if (obj1) {
51337 ecode2 = SWIG_AsVal_int(obj1, &val2);
51338 if (!SWIG_IsOK(ecode2)) {
51339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51340 }
51341 arg2 = static_cast< int >(val2);
51342 }
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51350 return resultobj;
51351 fail:
51352 return NULL;
51353 }
51354
51355
51356 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51357 PyObject *resultobj = 0;
51358 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51359 wxStaticBox *result = 0 ;
51360 void *argp1 = 0 ;
51361 int res1 = 0 ;
51362 PyObject *swig_obj[1] ;
51363
51364 if (!args) SWIG_fail;
51365 swig_obj[0] = args;
51366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51367 if (!SWIG_IsOK(res1)) {
51368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51369 }
51370 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51371 {
51372 PyThreadState* __tstate = wxPyBeginAllowThreads();
51373 result = (wxStaticBox *)(arg1)->GetStaticBox();
51374 wxPyEndAllowThreads(__tstate);
51375 if (PyErr_Occurred()) SWIG_fail;
51376 }
51377 {
51378 resultobj = wxPyMake_wxObject(result, (bool)0);
51379 }
51380 return resultobj;
51381 fail:
51382 return NULL;
51383 }
51384
51385
51386 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51387 PyObject *obj;
51388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51389 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51390 return SWIG_Py_Void();
51391 }
51392
51393 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51394 return SWIG_Python_InitShadowInstance(args);
51395 }
51396
51397 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51398 PyObject *resultobj = 0;
51399 int arg1 = (int) 1 ;
51400 int arg2 = (int) 0 ;
51401 int arg3 = (int) 0 ;
51402 int arg4 = (int) 0 ;
51403 wxGridSizer *result = 0 ;
51404 int val1 ;
51405 int ecode1 = 0 ;
51406 int val2 ;
51407 int ecode2 = 0 ;
51408 int val3 ;
51409 int ecode3 = 0 ;
51410 int val4 ;
51411 int ecode4 = 0 ;
51412 PyObject * obj0 = 0 ;
51413 PyObject * obj1 = 0 ;
51414 PyObject * obj2 = 0 ;
51415 PyObject * obj3 = 0 ;
51416 char * kwnames[] = {
51417 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51418 };
51419
51420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51421 if (obj0) {
51422 ecode1 = SWIG_AsVal_int(obj0, &val1);
51423 if (!SWIG_IsOK(ecode1)) {
51424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51425 }
51426 arg1 = static_cast< int >(val1);
51427 }
51428 if (obj1) {
51429 ecode2 = SWIG_AsVal_int(obj1, &val2);
51430 if (!SWIG_IsOK(ecode2)) {
51431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51432 }
51433 arg2 = static_cast< int >(val2);
51434 }
51435 if (obj2) {
51436 ecode3 = SWIG_AsVal_int(obj2, &val3);
51437 if (!SWIG_IsOK(ecode3)) {
51438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51439 }
51440 arg3 = static_cast< int >(val3);
51441 }
51442 if (obj3) {
51443 ecode4 = SWIG_AsVal_int(obj3, &val4);
51444 if (!SWIG_IsOK(ecode4)) {
51445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51446 }
51447 arg4 = static_cast< int >(val4);
51448 }
51449 {
51450 PyThreadState* __tstate = wxPyBeginAllowThreads();
51451 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51452 wxPyEndAllowThreads(__tstate);
51453 if (PyErr_Occurred()) SWIG_fail;
51454 }
51455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51456 return resultobj;
51457 fail:
51458 return NULL;
51459 }
51460
51461
51462 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51463 PyObject *resultobj = 0;
51464 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51465 int arg2 ;
51466 void *argp1 = 0 ;
51467 int res1 = 0 ;
51468 int val2 ;
51469 int ecode2 = 0 ;
51470 PyObject * obj0 = 0 ;
51471 PyObject * obj1 = 0 ;
51472 char * kwnames[] = {
51473 (char *) "self",(char *) "cols", NULL
51474 };
51475
51476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51478 if (!SWIG_IsOK(res1)) {
51479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51480 }
51481 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51482 ecode2 = SWIG_AsVal_int(obj1, &val2);
51483 if (!SWIG_IsOK(ecode2)) {
51484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51485 }
51486 arg2 = static_cast< int >(val2);
51487 {
51488 PyThreadState* __tstate = wxPyBeginAllowThreads();
51489 (arg1)->SetCols(arg2);
51490 wxPyEndAllowThreads(__tstate);
51491 if (PyErr_Occurred()) SWIG_fail;
51492 }
51493 resultobj = SWIG_Py_Void();
51494 return resultobj;
51495 fail:
51496 return NULL;
51497 }
51498
51499
51500 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51501 PyObject *resultobj = 0;
51502 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51503 int arg2 ;
51504 void *argp1 = 0 ;
51505 int res1 = 0 ;
51506 int val2 ;
51507 int ecode2 = 0 ;
51508 PyObject * obj0 = 0 ;
51509 PyObject * obj1 = 0 ;
51510 char * kwnames[] = {
51511 (char *) "self",(char *) "rows", NULL
51512 };
51513
51514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51516 if (!SWIG_IsOK(res1)) {
51517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51518 }
51519 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51520 ecode2 = SWIG_AsVal_int(obj1, &val2);
51521 if (!SWIG_IsOK(ecode2)) {
51522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51523 }
51524 arg2 = static_cast< int >(val2);
51525 {
51526 PyThreadState* __tstate = wxPyBeginAllowThreads();
51527 (arg1)->SetRows(arg2);
51528 wxPyEndAllowThreads(__tstate);
51529 if (PyErr_Occurred()) SWIG_fail;
51530 }
51531 resultobj = SWIG_Py_Void();
51532 return resultobj;
51533 fail:
51534 return NULL;
51535 }
51536
51537
51538 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51539 PyObject *resultobj = 0;
51540 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51541 int arg2 ;
51542 void *argp1 = 0 ;
51543 int res1 = 0 ;
51544 int val2 ;
51545 int ecode2 = 0 ;
51546 PyObject * obj0 = 0 ;
51547 PyObject * obj1 = 0 ;
51548 char * kwnames[] = {
51549 (char *) "self",(char *) "gap", NULL
51550 };
51551
51552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51554 if (!SWIG_IsOK(res1)) {
51555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51556 }
51557 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51558 ecode2 = SWIG_AsVal_int(obj1, &val2);
51559 if (!SWIG_IsOK(ecode2)) {
51560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51561 }
51562 arg2 = static_cast< int >(val2);
51563 {
51564 PyThreadState* __tstate = wxPyBeginAllowThreads();
51565 (arg1)->SetVGap(arg2);
51566 wxPyEndAllowThreads(__tstate);
51567 if (PyErr_Occurred()) SWIG_fail;
51568 }
51569 resultobj = SWIG_Py_Void();
51570 return resultobj;
51571 fail:
51572 return NULL;
51573 }
51574
51575
51576 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51577 PyObject *resultobj = 0;
51578 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51579 int arg2 ;
51580 void *argp1 = 0 ;
51581 int res1 = 0 ;
51582 int val2 ;
51583 int ecode2 = 0 ;
51584 PyObject * obj0 = 0 ;
51585 PyObject * obj1 = 0 ;
51586 char * kwnames[] = {
51587 (char *) "self",(char *) "gap", NULL
51588 };
51589
51590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51592 if (!SWIG_IsOK(res1)) {
51593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51594 }
51595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51596 ecode2 = SWIG_AsVal_int(obj1, &val2);
51597 if (!SWIG_IsOK(ecode2)) {
51598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51599 }
51600 arg2 = static_cast< int >(val2);
51601 {
51602 PyThreadState* __tstate = wxPyBeginAllowThreads();
51603 (arg1)->SetHGap(arg2);
51604 wxPyEndAllowThreads(__tstate);
51605 if (PyErr_Occurred()) SWIG_fail;
51606 }
51607 resultobj = SWIG_Py_Void();
51608 return resultobj;
51609 fail:
51610 return NULL;
51611 }
51612
51613
51614 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51615 PyObject *resultobj = 0;
51616 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51617 int result;
51618 void *argp1 = 0 ;
51619 int res1 = 0 ;
51620 PyObject *swig_obj[1] ;
51621
51622 if (!args) SWIG_fail;
51623 swig_obj[0] = args;
51624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51625 if (!SWIG_IsOK(res1)) {
51626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51627 }
51628 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51629 {
51630 PyThreadState* __tstate = wxPyBeginAllowThreads();
51631 result = (int)(arg1)->GetCols();
51632 wxPyEndAllowThreads(__tstate);
51633 if (PyErr_Occurred()) SWIG_fail;
51634 }
51635 resultobj = SWIG_From_int(static_cast< int >(result));
51636 return resultobj;
51637 fail:
51638 return NULL;
51639 }
51640
51641
51642 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51643 PyObject *resultobj = 0;
51644 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51645 int result;
51646 void *argp1 = 0 ;
51647 int res1 = 0 ;
51648 PyObject *swig_obj[1] ;
51649
51650 if (!args) SWIG_fail;
51651 swig_obj[0] = args;
51652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51653 if (!SWIG_IsOK(res1)) {
51654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51655 }
51656 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51657 {
51658 PyThreadState* __tstate = wxPyBeginAllowThreads();
51659 result = (int)(arg1)->GetRows();
51660 wxPyEndAllowThreads(__tstate);
51661 if (PyErr_Occurred()) SWIG_fail;
51662 }
51663 resultobj = SWIG_From_int(static_cast< int >(result));
51664 return resultobj;
51665 fail:
51666 return NULL;
51667 }
51668
51669
51670 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51671 PyObject *resultobj = 0;
51672 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51673 int result;
51674 void *argp1 = 0 ;
51675 int res1 = 0 ;
51676 PyObject *swig_obj[1] ;
51677
51678 if (!args) SWIG_fail;
51679 swig_obj[0] = args;
51680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51681 if (!SWIG_IsOK(res1)) {
51682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51683 }
51684 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51685 {
51686 PyThreadState* __tstate = wxPyBeginAllowThreads();
51687 result = (int)(arg1)->GetVGap();
51688 wxPyEndAllowThreads(__tstate);
51689 if (PyErr_Occurred()) SWIG_fail;
51690 }
51691 resultobj = SWIG_From_int(static_cast< int >(result));
51692 return resultobj;
51693 fail:
51694 return NULL;
51695 }
51696
51697
51698 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51699 PyObject *resultobj = 0;
51700 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51701 int result;
51702 void *argp1 = 0 ;
51703 int res1 = 0 ;
51704 PyObject *swig_obj[1] ;
51705
51706 if (!args) SWIG_fail;
51707 swig_obj[0] = args;
51708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51709 if (!SWIG_IsOK(res1)) {
51710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51711 }
51712 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51713 {
51714 PyThreadState* __tstate = wxPyBeginAllowThreads();
51715 result = (int)(arg1)->GetHGap();
51716 wxPyEndAllowThreads(__tstate);
51717 if (PyErr_Occurred()) SWIG_fail;
51718 }
51719 resultobj = SWIG_From_int(static_cast< int >(result));
51720 return resultobj;
51721 fail:
51722 return NULL;
51723 }
51724
51725
51726 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51727 PyObject *obj;
51728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51729 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51730 return SWIG_Py_Void();
51731 }
51732
51733 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51734 return SWIG_Python_InitShadowInstance(args);
51735 }
51736
51737 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51738 PyObject *resultobj = 0;
51739 int arg1 = (int) 1 ;
51740 int arg2 = (int) 0 ;
51741 int arg3 = (int) 0 ;
51742 int arg4 = (int) 0 ;
51743 wxFlexGridSizer *result = 0 ;
51744 int val1 ;
51745 int ecode1 = 0 ;
51746 int val2 ;
51747 int ecode2 = 0 ;
51748 int val3 ;
51749 int ecode3 = 0 ;
51750 int val4 ;
51751 int ecode4 = 0 ;
51752 PyObject * obj0 = 0 ;
51753 PyObject * obj1 = 0 ;
51754 PyObject * obj2 = 0 ;
51755 PyObject * obj3 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51761 if (obj0) {
51762 ecode1 = SWIG_AsVal_int(obj0, &val1);
51763 if (!SWIG_IsOK(ecode1)) {
51764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51765 }
51766 arg1 = static_cast< int >(val1);
51767 }
51768 if (obj1) {
51769 ecode2 = SWIG_AsVal_int(obj1, &val2);
51770 if (!SWIG_IsOK(ecode2)) {
51771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51772 }
51773 arg2 = static_cast< int >(val2);
51774 }
51775 if (obj2) {
51776 ecode3 = SWIG_AsVal_int(obj2, &val3);
51777 if (!SWIG_IsOK(ecode3)) {
51778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51779 }
51780 arg3 = static_cast< int >(val3);
51781 }
51782 if (obj3) {
51783 ecode4 = SWIG_AsVal_int(obj3, &val4);
51784 if (!SWIG_IsOK(ecode4)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51786 }
51787 arg4 = static_cast< int >(val4);
51788 }
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51803 PyObject *resultobj = 0;
51804 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51805 size_t arg2 ;
51806 int arg3 = (int) 0 ;
51807 void *argp1 = 0 ;
51808 int res1 = 0 ;
51809 size_t val2 ;
51810 int ecode2 = 0 ;
51811 int val3 ;
51812 int ecode3 = 0 ;
51813 PyObject * obj0 = 0 ;
51814 PyObject * obj1 = 0 ;
51815 PyObject * obj2 = 0 ;
51816 char * kwnames[] = {
51817 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51818 };
51819
51820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51822 if (!SWIG_IsOK(res1)) {
51823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51824 }
51825 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51826 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51827 if (!SWIG_IsOK(ecode2)) {
51828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51829 }
51830 arg2 = static_cast< size_t >(val2);
51831 if (obj2) {
51832 ecode3 = SWIG_AsVal_int(obj2, &val3);
51833 if (!SWIG_IsOK(ecode3)) {
51834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51835 }
51836 arg3 = static_cast< int >(val3);
51837 }
51838 {
51839 PyThreadState* __tstate = wxPyBeginAllowThreads();
51840 (arg1)->AddGrowableRow(arg2,arg3);
51841 wxPyEndAllowThreads(__tstate);
51842 if (PyErr_Occurred()) SWIG_fail;
51843 }
51844 resultobj = SWIG_Py_Void();
51845 return resultobj;
51846 fail:
51847 return NULL;
51848 }
51849
51850
51851 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51852 PyObject *resultobj = 0;
51853 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51854 size_t arg2 ;
51855 void *argp1 = 0 ;
51856 int res1 = 0 ;
51857 size_t val2 ;
51858 int ecode2 = 0 ;
51859 PyObject * obj0 = 0 ;
51860 PyObject * obj1 = 0 ;
51861 char * kwnames[] = {
51862 (char *) "self",(char *) "idx", NULL
51863 };
51864
51865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51867 if (!SWIG_IsOK(res1)) {
51868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51869 }
51870 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51872 if (!SWIG_IsOK(ecode2)) {
51873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51874 }
51875 arg2 = static_cast< size_t >(val2);
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 (arg1)->RemoveGrowableRow(arg2);
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 resultobj = SWIG_Py_Void();
51883 return resultobj;
51884 fail:
51885 return NULL;
51886 }
51887
51888
51889 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51890 PyObject *resultobj = 0;
51891 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51892 size_t arg2 ;
51893 int arg3 = (int) 0 ;
51894 void *argp1 = 0 ;
51895 int res1 = 0 ;
51896 size_t val2 ;
51897 int ecode2 = 0 ;
51898 int val3 ;
51899 int ecode3 = 0 ;
51900 PyObject * obj0 = 0 ;
51901 PyObject * obj1 = 0 ;
51902 PyObject * obj2 = 0 ;
51903 char * kwnames[] = {
51904 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51905 };
51906
51907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51909 if (!SWIG_IsOK(res1)) {
51910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51911 }
51912 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51913 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51914 if (!SWIG_IsOK(ecode2)) {
51915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51916 }
51917 arg2 = static_cast< size_t >(val2);
51918 if (obj2) {
51919 ecode3 = SWIG_AsVal_int(obj2, &val3);
51920 if (!SWIG_IsOK(ecode3)) {
51921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51922 }
51923 arg3 = static_cast< int >(val3);
51924 }
51925 {
51926 PyThreadState* __tstate = wxPyBeginAllowThreads();
51927 (arg1)->AddGrowableCol(arg2,arg3);
51928 wxPyEndAllowThreads(__tstate);
51929 if (PyErr_Occurred()) SWIG_fail;
51930 }
51931 resultobj = SWIG_Py_Void();
51932 return resultobj;
51933 fail:
51934 return NULL;
51935 }
51936
51937
51938 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51939 PyObject *resultobj = 0;
51940 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51941 size_t arg2 ;
51942 void *argp1 = 0 ;
51943 int res1 = 0 ;
51944 size_t val2 ;
51945 int ecode2 = 0 ;
51946 PyObject * obj0 = 0 ;
51947 PyObject * obj1 = 0 ;
51948 char * kwnames[] = {
51949 (char *) "self",(char *) "idx", NULL
51950 };
51951
51952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51954 if (!SWIG_IsOK(res1)) {
51955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51956 }
51957 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51958 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51959 if (!SWIG_IsOK(ecode2)) {
51960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51961 }
51962 arg2 = static_cast< size_t >(val2);
51963 {
51964 PyThreadState* __tstate = wxPyBeginAllowThreads();
51965 (arg1)->RemoveGrowableCol(arg2);
51966 wxPyEndAllowThreads(__tstate);
51967 if (PyErr_Occurred()) SWIG_fail;
51968 }
51969 resultobj = SWIG_Py_Void();
51970 return resultobj;
51971 fail:
51972 return NULL;
51973 }
51974
51975
51976 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51977 PyObject *resultobj = 0;
51978 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51979 int arg2 ;
51980 void *argp1 = 0 ;
51981 int res1 = 0 ;
51982 int val2 ;
51983 int ecode2 = 0 ;
51984 PyObject * obj0 = 0 ;
51985 PyObject * obj1 = 0 ;
51986 char * kwnames[] = {
51987 (char *) "self",(char *) "direction", NULL
51988 };
51989
51990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51992 if (!SWIG_IsOK(res1)) {
51993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51994 }
51995 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51996 ecode2 = SWIG_AsVal_int(obj1, &val2);
51997 if (!SWIG_IsOK(ecode2)) {
51998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51999 }
52000 arg2 = static_cast< int >(val2);
52001 {
52002 PyThreadState* __tstate = wxPyBeginAllowThreads();
52003 (arg1)->SetFlexibleDirection(arg2);
52004 wxPyEndAllowThreads(__tstate);
52005 if (PyErr_Occurred()) SWIG_fail;
52006 }
52007 resultobj = SWIG_Py_Void();
52008 return resultobj;
52009 fail:
52010 return NULL;
52011 }
52012
52013
52014 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52015 PyObject *resultobj = 0;
52016 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52017 int result;
52018 void *argp1 = 0 ;
52019 int res1 = 0 ;
52020 PyObject *swig_obj[1] ;
52021
52022 if (!args) SWIG_fail;
52023 swig_obj[0] = args;
52024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52025 if (!SWIG_IsOK(res1)) {
52026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52027 }
52028 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52029 {
52030 PyThreadState* __tstate = wxPyBeginAllowThreads();
52031 result = (int)(arg1)->GetFlexibleDirection();
52032 wxPyEndAllowThreads(__tstate);
52033 if (PyErr_Occurred()) SWIG_fail;
52034 }
52035 resultobj = SWIG_From_int(static_cast< int >(result));
52036 return resultobj;
52037 fail:
52038 return NULL;
52039 }
52040
52041
52042 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52043 PyObject *resultobj = 0;
52044 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52045 wxFlexSizerGrowMode arg2 ;
52046 void *argp1 = 0 ;
52047 int res1 = 0 ;
52048 int val2 ;
52049 int ecode2 = 0 ;
52050 PyObject * obj0 = 0 ;
52051 PyObject * obj1 = 0 ;
52052 char * kwnames[] = {
52053 (char *) "self",(char *) "mode", NULL
52054 };
52055
52056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52058 if (!SWIG_IsOK(res1)) {
52059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52060 }
52061 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52062 ecode2 = SWIG_AsVal_int(obj1, &val2);
52063 if (!SWIG_IsOK(ecode2)) {
52064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52065 }
52066 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52067 {
52068 PyThreadState* __tstate = wxPyBeginAllowThreads();
52069 (arg1)->SetNonFlexibleGrowMode(arg2);
52070 wxPyEndAllowThreads(__tstate);
52071 if (PyErr_Occurred()) SWIG_fail;
52072 }
52073 resultobj = SWIG_Py_Void();
52074 return resultobj;
52075 fail:
52076 return NULL;
52077 }
52078
52079
52080 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52081 PyObject *resultobj = 0;
52082 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52083 wxFlexSizerGrowMode result;
52084 void *argp1 = 0 ;
52085 int res1 = 0 ;
52086 PyObject *swig_obj[1] ;
52087
52088 if (!args) SWIG_fail;
52089 swig_obj[0] = args;
52090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52093 }
52094 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52095 {
52096 PyThreadState* __tstate = wxPyBeginAllowThreads();
52097 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52098 wxPyEndAllowThreads(__tstate);
52099 if (PyErr_Occurred()) SWIG_fail;
52100 }
52101 resultobj = SWIG_From_int(static_cast< int >(result));
52102 return resultobj;
52103 fail:
52104 return NULL;
52105 }
52106
52107
52108 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52109 PyObject *resultobj = 0;
52110 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52111 wxArrayInt *result = 0 ;
52112 void *argp1 = 0 ;
52113 int res1 = 0 ;
52114 PyObject *swig_obj[1] ;
52115
52116 if (!args) SWIG_fail;
52117 swig_obj[0] = args;
52118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52119 if (!SWIG_IsOK(res1)) {
52120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52121 }
52122 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52123 {
52124 PyThreadState* __tstate = wxPyBeginAllowThreads();
52125 {
52126 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52127 result = (wxArrayInt *) &_result_ref;
52128 }
52129 wxPyEndAllowThreads(__tstate);
52130 if (PyErr_Occurred()) SWIG_fail;
52131 }
52132 {
52133 resultobj = wxArrayInt2PyList_helper(*result);
52134 }
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52142 PyObject *resultobj = 0;
52143 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52144 wxArrayInt *result = 0 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 PyObject *swig_obj[1] ;
52148
52149 if (!args) SWIG_fail;
52150 swig_obj[0] = args;
52151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52154 }
52155 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52156 {
52157 PyThreadState* __tstate = wxPyBeginAllowThreads();
52158 {
52159 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52160 result = (wxArrayInt *) &_result_ref;
52161 }
52162 wxPyEndAllowThreads(__tstate);
52163 if (PyErr_Occurred()) SWIG_fail;
52164 }
52165 {
52166 resultobj = wxArrayInt2PyList_helper(*result);
52167 }
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *obj;
52176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52177 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52178 return SWIG_Py_Void();
52179 }
52180
52181 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52182 return SWIG_Python_InitShadowInstance(args);
52183 }
52184
52185 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52186 PyObject *resultobj = 0;
52187 wxStdDialogButtonSizer *result = 0 ;
52188
52189 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52190 {
52191 PyThreadState* __tstate = wxPyBeginAllowThreads();
52192 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52193 wxPyEndAllowThreads(__tstate);
52194 if (PyErr_Occurred()) SWIG_fail;
52195 }
52196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52197 return resultobj;
52198 fail:
52199 return NULL;
52200 }
52201
52202
52203 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52204 PyObject *resultobj = 0;
52205 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52206 wxButton *arg2 = (wxButton *) 0 ;
52207 void *argp1 = 0 ;
52208 int res1 = 0 ;
52209 void *argp2 = 0 ;
52210 int res2 = 0 ;
52211 PyObject * obj0 = 0 ;
52212 PyObject * obj1 = 0 ;
52213 char * kwnames[] = {
52214 (char *) "self",(char *) "button", NULL
52215 };
52216
52217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52219 if (!SWIG_IsOK(res1)) {
52220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52221 }
52222 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52224 if (!SWIG_IsOK(res2)) {
52225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52226 }
52227 arg2 = reinterpret_cast< wxButton * >(argp2);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 (arg1)->AddButton(arg2);
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 resultobj = SWIG_Py_Void();
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52242 PyObject *resultobj = 0;
52243 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52244 void *argp1 = 0 ;
52245 int res1 = 0 ;
52246 PyObject *swig_obj[1] ;
52247
52248 if (!args) SWIG_fail;
52249 swig_obj[0] = args;
52250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52251 if (!SWIG_IsOK(res1)) {
52252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52253 }
52254 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52255 {
52256 PyThreadState* __tstate = wxPyBeginAllowThreads();
52257 (arg1)->Realize();
52258 wxPyEndAllowThreads(__tstate);
52259 if (PyErr_Occurred()) SWIG_fail;
52260 }
52261 resultobj = SWIG_Py_Void();
52262 return resultobj;
52263 fail:
52264 return NULL;
52265 }
52266
52267
52268 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52269 PyObject *resultobj = 0;
52270 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52271 wxButton *arg2 = (wxButton *) 0 ;
52272 void *argp1 = 0 ;
52273 int res1 = 0 ;
52274 void *argp2 = 0 ;
52275 int res2 = 0 ;
52276 PyObject * obj0 = 0 ;
52277 PyObject * obj1 = 0 ;
52278 char * kwnames[] = {
52279 (char *) "self",(char *) "button", NULL
52280 };
52281
52282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52284 if (!SWIG_IsOK(res1)) {
52285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52286 }
52287 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52289 if (!SWIG_IsOK(res2)) {
52290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52291 }
52292 arg2 = reinterpret_cast< wxButton * >(argp2);
52293 {
52294 PyThreadState* __tstate = wxPyBeginAllowThreads();
52295 (arg1)->SetAffirmativeButton(arg2);
52296 wxPyEndAllowThreads(__tstate);
52297 if (PyErr_Occurred()) SWIG_fail;
52298 }
52299 resultobj = SWIG_Py_Void();
52300 return resultobj;
52301 fail:
52302 return NULL;
52303 }
52304
52305
52306 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52307 PyObject *resultobj = 0;
52308 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52309 wxButton *arg2 = (wxButton *) 0 ;
52310 void *argp1 = 0 ;
52311 int res1 = 0 ;
52312 void *argp2 = 0 ;
52313 int res2 = 0 ;
52314 PyObject * obj0 = 0 ;
52315 PyObject * obj1 = 0 ;
52316 char * kwnames[] = {
52317 (char *) "self",(char *) "button", NULL
52318 };
52319
52320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52324 }
52325 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52327 if (!SWIG_IsOK(res2)) {
52328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52329 }
52330 arg2 = reinterpret_cast< wxButton * >(argp2);
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 (arg1)->SetNegativeButton(arg2);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 resultobj = SWIG_Py_Void();
52338 return resultobj;
52339 fail:
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52345 PyObject *resultobj = 0;
52346 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52347 wxButton *arg2 = (wxButton *) 0 ;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 void *argp2 = 0 ;
52351 int res2 = 0 ;
52352 PyObject * obj0 = 0 ;
52353 PyObject * obj1 = 0 ;
52354 char * kwnames[] = {
52355 (char *) "self",(char *) "button", NULL
52356 };
52357
52358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52360 if (!SWIG_IsOK(res1)) {
52361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52362 }
52363 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52365 if (!SWIG_IsOK(res2)) {
52366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52367 }
52368 arg2 = reinterpret_cast< wxButton * >(argp2);
52369 {
52370 PyThreadState* __tstate = wxPyBeginAllowThreads();
52371 (arg1)->SetCancelButton(arg2);
52372 wxPyEndAllowThreads(__tstate);
52373 if (PyErr_Occurred()) SWIG_fail;
52374 }
52375 resultobj = SWIG_Py_Void();
52376 return resultobj;
52377 fail:
52378 return NULL;
52379 }
52380
52381
52382 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52383 PyObject *resultobj = 0;
52384 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52385 wxButton *result = 0 ;
52386 void *argp1 = 0 ;
52387 int res1 = 0 ;
52388 PyObject *swig_obj[1] ;
52389
52390 if (!args) SWIG_fail;
52391 swig_obj[0] = args;
52392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52395 }
52396 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52397 {
52398 PyThreadState* __tstate = wxPyBeginAllowThreads();
52399 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52400 wxPyEndAllowThreads(__tstate);
52401 if (PyErr_Occurred()) SWIG_fail;
52402 }
52403 {
52404 resultobj = wxPyMake_wxObject(result, (bool)0);
52405 }
52406 return resultobj;
52407 fail:
52408 return NULL;
52409 }
52410
52411
52412 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52413 PyObject *resultobj = 0;
52414 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52415 wxButton *result = 0 ;
52416 void *argp1 = 0 ;
52417 int res1 = 0 ;
52418 PyObject *swig_obj[1] ;
52419
52420 if (!args) SWIG_fail;
52421 swig_obj[0] = args;
52422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52423 if (!SWIG_IsOK(res1)) {
52424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52425 }
52426 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52427 {
52428 PyThreadState* __tstate = wxPyBeginAllowThreads();
52429 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52430 wxPyEndAllowThreads(__tstate);
52431 if (PyErr_Occurred()) SWIG_fail;
52432 }
52433 {
52434 resultobj = wxPyMake_wxObject(result, (bool)0);
52435 }
52436 return resultobj;
52437 fail:
52438 return NULL;
52439 }
52440
52441
52442 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52443 PyObject *resultobj = 0;
52444 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52445 wxButton *result = 0 ;
52446 void *argp1 = 0 ;
52447 int res1 = 0 ;
52448 PyObject *swig_obj[1] ;
52449
52450 if (!args) SWIG_fail;
52451 swig_obj[0] = args;
52452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52453 if (!SWIG_IsOK(res1)) {
52454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52455 }
52456 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52457 {
52458 PyThreadState* __tstate = wxPyBeginAllowThreads();
52459 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52460 wxPyEndAllowThreads(__tstate);
52461 if (PyErr_Occurred()) SWIG_fail;
52462 }
52463 {
52464 resultobj = wxPyMake_wxObject(result, (bool)0);
52465 }
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 PyObject *resultobj = 0;
52474 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52475 wxButton *result = 0 ;
52476 void *argp1 = 0 ;
52477 int res1 = 0 ;
52478 PyObject *swig_obj[1] ;
52479
52480 if (!args) SWIG_fail;
52481 swig_obj[0] = args;
52482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52483 if (!SWIG_IsOK(res1)) {
52484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52485 }
52486 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52487 {
52488 PyThreadState* __tstate = wxPyBeginAllowThreads();
52489 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52490 wxPyEndAllowThreads(__tstate);
52491 if (PyErr_Occurred()) SWIG_fail;
52492 }
52493 {
52494 resultobj = wxPyMake_wxObject(result, (bool)0);
52495 }
52496 return resultobj;
52497 fail:
52498 return NULL;
52499 }
52500
52501
52502 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52503 PyObject *resultobj = 0;
52504 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52505 wxButton *result = 0 ;
52506 void *argp1 = 0 ;
52507 int res1 = 0 ;
52508 PyObject *swig_obj[1] ;
52509
52510 if (!args) SWIG_fail;
52511 swig_obj[0] = args;
52512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52513 if (!SWIG_IsOK(res1)) {
52514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52515 }
52516 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52517 {
52518 PyThreadState* __tstate = wxPyBeginAllowThreads();
52519 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52520 wxPyEndAllowThreads(__tstate);
52521 if (PyErr_Occurred()) SWIG_fail;
52522 }
52523 {
52524 resultobj = wxPyMake_wxObject(result, (bool)0);
52525 }
52526 return resultobj;
52527 fail:
52528 return NULL;
52529 }
52530
52531
52532 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52533 PyObject *obj;
52534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52535 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52536 return SWIG_Py_Void();
52537 }
52538
52539 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52540 return SWIG_Python_InitShadowInstance(args);
52541 }
52542
52543 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52544 PyObject *resultobj = 0;
52545 int arg1 = (int) 0 ;
52546 int arg2 = (int) 0 ;
52547 wxGBPosition *result = 0 ;
52548 int val1 ;
52549 int ecode1 = 0 ;
52550 int val2 ;
52551 int ecode2 = 0 ;
52552 PyObject * obj0 = 0 ;
52553 PyObject * obj1 = 0 ;
52554 char * kwnames[] = {
52555 (char *) "row",(char *) "col", NULL
52556 };
52557
52558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52559 if (obj0) {
52560 ecode1 = SWIG_AsVal_int(obj0, &val1);
52561 if (!SWIG_IsOK(ecode1)) {
52562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52563 }
52564 arg1 = static_cast< int >(val1);
52565 }
52566 if (obj1) {
52567 ecode2 = SWIG_AsVal_int(obj1, &val2);
52568 if (!SWIG_IsOK(ecode2)) {
52569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52570 }
52571 arg2 = static_cast< int >(val2);
52572 }
52573 {
52574 PyThreadState* __tstate = wxPyBeginAllowThreads();
52575 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52576 wxPyEndAllowThreads(__tstate);
52577 if (PyErr_Occurred()) SWIG_fail;
52578 }
52579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52580 return resultobj;
52581 fail:
52582 return NULL;
52583 }
52584
52585
52586 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52587 PyObject *resultobj = 0;
52588 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52589 void *argp1 = 0 ;
52590 int res1 = 0 ;
52591 PyObject *swig_obj[1] ;
52592
52593 if (!args) SWIG_fail;
52594 swig_obj[0] = args;
52595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52596 if (!SWIG_IsOK(res1)) {
52597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52598 }
52599 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52600 {
52601 PyThreadState* __tstate = wxPyBeginAllowThreads();
52602 delete arg1;
52603
52604 wxPyEndAllowThreads(__tstate);
52605 if (PyErr_Occurred()) SWIG_fail;
52606 }
52607 resultobj = SWIG_Py_Void();
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52615 PyObject *resultobj = 0;
52616 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52617 int result;
52618 void *argp1 = 0 ;
52619 int res1 = 0 ;
52620 PyObject *swig_obj[1] ;
52621
52622 if (!args) SWIG_fail;
52623 swig_obj[0] = args;
52624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52625 if (!SWIG_IsOK(res1)) {
52626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52627 }
52628 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52629 {
52630 PyThreadState* __tstate = wxPyBeginAllowThreads();
52631 result = (int)((wxGBPosition const *)arg1)->GetRow();
52632 wxPyEndAllowThreads(__tstate);
52633 if (PyErr_Occurred()) SWIG_fail;
52634 }
52635 resultobj = SWIG_From_int(static_cast< int >(result));
52636 return resultobj;
52637 fail:
52638 return NULL;
52639 }
52640
52641
52642 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52643 PyObject *resultobj = 0;
52644 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52645 int result;
52646 void *argp1 = 0 ;
52647 int res1 = 0 ;
52648 PyObject *swig_obj[1] ;
52649
52650 if (!args) SWIG_fail;
52651 swig_obj[0] = args;
52652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52653 if (!SWIG_IsOK(res1)) {
52654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52655 }
52656 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52657 {
52658 PyThreadState* __tstate = wxPyBeginAllowThreads();
52659 result = (int)((wxGBPosition const *)arg1)->GetCol();
52660 wxPyEndAllowThreads(__tstate);
52661 if (PyErr_Occurred()) SWIG_fail;
52662 }
52663 resultobj = SWIG_From_int(static_cast< int >(result));
52664 return resultobj;
52665 fail:
52666 return NULL;
52667 }
52668
52669
52670 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52671 PyObject *resultobj = 0;
52672 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52673 int arg2 ;
52674 void *argp1 = 0 ;
52675 int res1 = 0 ;
52676 int val2 ;
52677 int ecode2 = 0 ;
52678 PyObject * obj0 = 0 ;
52679 PyObject * obj1 = 0 ;
52680 char * kwnames[] = {
52681 (char *) "self",(char *) "row", NULL
52682 };
52683
52684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52686 if (!SWIG_IsOK(res1)) {
52687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52688 }
52689 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52690 ecode2 = SWIG_AsVal_int(obj1, &val2);
52691 if (!SWIG_IsOK(ecode2)) {
52692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52693 }
52694 arg2 = static_cast< int >(val2);
52695 {
52696 PyThreadState* __tstate = wxPyBeginAllowThreads();
52697 (arg1)->SetRow(arg2);
52698 wxPyEndAllowThreads(__tstate);
52699 if (PyErr_Occurred()) SWIG_fail;
52700 }
52701 resultobj = SWIG_Py_Void();
52702 return resultobj;
52703 fail:
52704 return NULL;
52705 }
52706
52707
52708 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52709 PyObject *resultobj = 0;
52710 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52711 int arg2 ;
52712 void *argp1 = 0 ;
52713 int res1 = 0 ;
52714 int val2 ;
52715 int ecode2 = 0 ;
52716 PyObject * obj0 = 0 ;
52717 PyObject * obj1 = 0 ;
52718 char * kwnames[] = {
52719 (char *) "self",(char *) "col", NULL
52720 };
52721
52722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52724 if (!SWIG_IsOK(res1)) {
52725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52726 }
52727 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52728 ecode2 = SWIG_AsVal_int(obj1, &val2);
52729 if (!SWIG_IsOK(ecode2)) {
52730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52731 }
52732 arg2 = static_cast< int >(val2);
52733 {
52734 PyThreadState* __tstate = wxPyBeginAllowThreads();
52735 (arg1)->SetCol(arg2);
52736 wxPyEndAllowThreads(__tstate);
52737 if (PyErr_Occurred()) SWIG_fail;
52738 }
52739 resultobj = SWIG_Py_Void();
52740 return resultobj;
52741 fail:
52742 return NULL;
52743 }
52744
52745
52746 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52747 PyObject *resultobj = 0;
52748 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52749 PyObject *arg2 = (PyObject *) 0 ;
52750 bool result;
52751 void *argp1 = 0 ;
52752 int res1 = 0 ;
52753 PyObject * obj0 = 0 ;
52754 PyObject * obj1 = 0 ;
52755 char * kwnames[] = {
52756 (char *) "self",(char *) "other", NULL
52757 };
52758
52759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52761 if (!SWIG_IsOK(res1)) {
52762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52763 }
52764 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52765 arg2 = obj1;
52766 {
52767 result = (bool)wxGBPosition___eq__(arg1,arg2);
52768 if (PyErr_Occurred()) SWIG_fail;
52769 }
52770 {
52771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52772 }
52773 return resultobj;
52774 fail:
52775 return NULL;
52776 }
52777
52778
52779 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52780 PyObject *resultobj = 0;
52781 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52782 PyObject *arg2 = (PyObject *) 0 ;
52783 bool result;
52784 void *argp1 = 0 ;
52785 int res1 = 0 ;
52786 PyObject * obj0 = 0 ;
52787 PyObject * obj1 = 0 ;
52788 char * kwnames[] = {
52789 (char *) "self",(char *) "other", NULL
52790 };
52791
52792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52794 if (!SWIG_IsOK(res1)) {
52795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52796 }
52797 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52798 arg2 = obj1;
52799 {
52800 result = (bool)wxGBPosition___ne__(arg1,arg2);
52801 if (PyErr_Occurred()) SWIG_fail;
52802 }
52803 {
52804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52805 }
52806 return resultobj;
52807 fail:
52808 return NULL;
52809 }
52810
52811
52812 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52813 PyObject *resultobj = 0;
52814 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52815 int arg2 = (int) 0 ;
52816 int arg3 = (int) 0 ;
52817 void *argp1 = 0 ;
52818 int res1 = 0 ;
52819 int val2 ;
52820 int ecode2 = 0 ;
52821 int val3 ;
52822 int ecode3 = 0 ;
52823 PyObject * obj0 = 0 ;
52824 PyObject * obj1 = 0 ;
52825 PyObject * obj2 = 0 ;
52826 char * kwnames[] = {
52827 (char *) "self",(char *) "row",(char *) "col", NULL
52828 };
52829
52830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52832 if (!SWIG_IsOK(res1)) {
52833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52834 }
52835 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52836 if (obj1) {
52837 ecode2 = SWIG_AsVal_int(obj1, &val2);
52838 if (!SWIG_IsOK(ecode2)) {
52839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52840 }
52841 arg2 = static_cast< int >(val2);
52842 }
52843 if (obj2) {
52844 ecode3 = SWIG_AsVal_int(obj2, &val3);
52845 if (!SWIG_IsOK(ecode3)) {
52846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52847 }
52848 arg3 = static_cast< int >(val3);
52849 }
52850 {
52851 PyThreadState* __tstate = wxPyBeginAllowThreads();
52852 wxGBPosition_Set(arg1,arg2,arg3);
52853 wxPyEndAllowThreads(__tstate);
52854 if (PyErr_Occurred()) SWIG_fail;
52855 }
52856 resultobj = SWIG_Py_Void();
52857 return resultobj;
52858 fail:
52859 return NULL;
52860 }
52861
52862
52863 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52864 PyObject *resultobj = 0;
52865 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52866 PyObject *result = 0 ;
52867 void *argp1 = 0 ;
52868 int res1 = 0 ;
52869 PyObject *swig_obj[1] ;
52870
52871 if (!args) SWIG_fail;
52872 swig_obj[0] = args;
52873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52874 if (!SWIG_IsOK(res1)) {
52875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52876 }
52877 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52878 {
52879 PyThreadState* __tstate = wxPyBeginAllowThreads();
52880 result = (PyObject *)wxGBPosition_Get(arg1);
52881 wxPyEndAllowThreads(__tstate);
52882 if (PyErr_Occurred()) SWIG_fail;
52883 }
52884 resultobj = result;
52885 return resultobj;
52886 fail:
52887 return NULL;
52888 }
52889
52890
52891 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52892 PyObject *obj;
52893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52894 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52895 return SWIG_Py_Void();
52896 }
52897
52898 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52899 return SWIG_Python_InitShadowInstance(args);
52900 }
52901
52902 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52903 PyObject *resultobj = 0;
52904 int arg1 = (int) 1 ;
52905 int arg2 = (int) 1 ;
52906 wxGBSpan *result = 0 ;
52907 int val1 ;
52908 int ecode1 = 0 ;
52909 int val2 ;
52910 int ecode2 = 0 ;
52911 PyObject * obj0 = 0 ;
52912 PyObject * obj1 = 0 ;
52913 char * kwnames[] = {
52914 (char *) "rowspan",(char *) "colspan", NULL
52915 };
52916
52917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52918 if (obj0) {
52919 ecode1 = SWIG_AsVal_int(obj0, &val1);
52920 if (!SWIG_IsOK(ecode1)) {
52921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52922 }
52923 arg1 = static_cast< int >(val1);
52924 }
52925 if (obj1) {
52926 ecode2 = SWIG_AsVal_int(obj1, &val2);
52927 if (!SWIG_IsOK(ecode2)) {
52928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52929 }
52930 arg2 = static_cast< int >(val2);
52931 }
52932 {
52933 PyThreadState* __tstate = wxPyBeginAllowThreads();
52934 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52935 wxPyEndAllowThreads(__tstate);
52936 if (PyErr_Occurred()) SWIG_fail;
52937 }
52938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52939 return resultobj;
52940 fail:
52941 return NULL;
52942 }
52943
52944
52945 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52946 PyObject *resultobj = 0;
52947 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52948 void *argp1 = 0 ;
52949 int res1 = 0 ;
52950 PyObject *swig_obj[1] ;
52951
52952 if (!args) SWIG_fail;
52953 swig_obj[0] = args;
52954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52955 if (!SWIG_IsOK(res1)) {
52956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52957 }
52958 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52959 {
52960 PyThreadState* __tstate = wxPyBeginAllowThreads();
52961 delete arg1;
52962
52963 wxPyEndAllowThreads(__tstate);
52964 if (PyErr_Occurred()) SWIG_fail;
52965 }
52966 resultobj = SWIG_Py_Void();
52967 return resultobj;
52968 fail:
52969 return NULL;
52970 }
52971
52972
52973 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52974 PyObject *resultobj = 0;
52975 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52976 int result;
52977 void *argp1 = 0 ;
52978 int res1 = 0 ;
52979 PyObject *swig_obj[1] ;
52980
52981 if (!args) SWIG_fail;
52982 swig_obj[0] = args;
52983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52984 if (!SWIG_IsOK(res1)) {
52985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52986 }
52987 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52988 {
52989 PyThreadState* __tstate = wxPyBeginAllowThreads();
52990 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52991 wxPyEndAllowThreads(__tstate);
52992 if (PyErr_Occurred()) SWIG_fail;
52993 }
52994 resultobj = SWIG_From_int(static_cast< int >(result));
52995 return resultobj;
52996 fail:
52997 return NULL;
52998 }
52999
53000
53001 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53002 PyObject *resultobj = 0;
53003 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53004 int result;
53005 void *argp1 = 0 ;
53006 int res1 = 0 ;
53007 PyObject *swig_obj[1] ;
53008
53009 if (!args) SWIG_fail;
53010 swig_obj[0] = args;
53011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53012 if (!SWIG_IsOK(res1)) {
53013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53014 }
53015 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53016 {
53017 PyThreadState* __tstate = wxPyBeginAllowThreads();
53018 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53019 wxPyEndAllowThreads(__tstate);
53020 if (PyErr_Occurred()) SWIG_fail;
53021 }
53022 resultobj = SWIG_From_int(static_cast< int >(result));
53023 return resultobj;
53024 fail:
53025 return NULL;
53026 }
53027
53028
53029 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53030 PyObject *resultobj = 0;
53031 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53032 int arg2 ;
53033 void *argp1 = 0 ;
53034 int res1 = 0 ;
53035 int val2 ;
53036 int ecode2 = 0 ;
53037 PyObject * obj0 = 0 ;
53038 PyObject * obj1 = 0 ;
53039 char * kwnames[] = {
53040 (char *) "self",(char *) "rowspan", NULL
53041 };
53042
53043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53045 if (!SWIG_IsOK(res1)) {
53046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53047 }
53048 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53049 ecode2 = SWIG_AsVal_int(obj1, &val2);
53050 if (!SWIG_IsOK(ecode2)) {
53051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53052 }
53053 arg2 = static_cast< int >(val2);
53054 {
53055 PyThreadState* __tstate = wxPyBeginAllowThreads();
53056 (arg1)->SetRowspan(arg2);
53057 wxPyEndAllowThreads(__tstate);
53058 if (PyErr_Occurred()) SWIG_fail;
53059 }
53060 resultobj = SWIG_Py_Void();
53061 return resultobj;
53062 fail:
53063 return NULL;
53064 }
53065
53066
53067 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53068 PyObject *resultobj = 0;
53069 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53070 int arg2 ;
53071 void *argp1 = 0 ;
53072 int res1 = 0 ;
53073 int val2 ;
53074 int ecode2 = 0 ;
53075 PyObject * obj0 = 0 ;
53076 PyObject * obj1 = 0 ;
53077 char * kwnames[] = {
53078 (char *) "self",(char *) "colspan", NULL
53079 };
53080
53081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53083 if (!SWIG_IsOK(res1)) {
53084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53085 }
53086 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53087 ecode2 = SWIG_AsVal_int(obj1, &val2);
53088 if (!SWIG_IsOK(ecode2)) {
53089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53090 }
53091 arg2 = static_cast< int >(val2);
53092 {
53093 PyThreadState* __tstate = wxPyBeginAllowThreads();
53094 (arg1)->SetColspan(arg2);
53095 wxPyEndAllowThreads(__tstate);
53096 if (PyErr_Occurred()) SWIG_fail;
53097 }
53098 resultobj = SWIG_Py_Void();
53099 return resultobj;
53100 fail:
53101 return NULL;
53102 }
53103
53104
53105 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53106 PyObject *resultobj = 0;
53107 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53108 PyObject *arg2 = (PyObject *) 0 ;
53109 bool result;
53110 void *argp1 = 0 ;
53111 int res1 = 0 ;
53112 PyObject * obj0 = 0 ;
53113 PyObject * obj1 = 0 ;
53114 char * kwnames[] = {
53115 (char *) "self",(char *) "other", NULL
53116 };
53117
53118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53120 if (!SWIG_IsOK(res1)) {
53121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53122 }
53123 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53124 arg2 = obj1;
53125 {
53126 result = (bool)wxGBSpan___eq__(arg1,arg2);
53127 if (PyErr_Occurred()) SWIG_fail;
53128 }
53129 {
53130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53131 }
53132 return resultobj;
53133 fail:
53134 return NULL;
53135 }
53136
53137
53138 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53139 PyObject *resultobj = 0;
53140 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53141 PyObject *arg2 = (PyObject *) 0 ;
53142 bool result;
53143 void *argp1 = 0 ;
53144 int res1 = 0 ;
53145 PyObject * obj0 = 0 ;
53146 PyObject * obj1 = 0 ;
53147 char * kwnames[] = {
53148 (char *) "self",(char *) "other", NULL
53149 };
53150
53151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53153 if (!SWIG_IsOK(res1)) {
53154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53155 }
53156 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53157 arg2 = obj1;
53158 {
53159 result = (bool)wxGBSpan___ne__(arg1,arg2);
53160 if (PyErr_Occurred()) SWIG_fail;
53161 }
53162 {
53163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53164 }
53165 return resultobj;
53166 fail:
53167 return NULL;
53168 }
53169
53170
53171 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53172 PyObject *resultobj = 0;
53173 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53174 int arg2 = (int) 1 ;
53175 int arg3 = (int) 1 ;
53176 void *argp1 = 0 ;
53177 int res1 = 0 ;
53178 int val2 ;
53179 int ecode2 = 0 ;
53180 int val3 ;
53181 int ecode3 = 0 ;
53182 PyObject * obj0 = 0 ;
53183 PyObject * obj1 = 0 ;
53184 PyObject * obj2 = 0 ;
53185 char * kwnames[] = {
53186 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53187 };
53188
53189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53191 if (!SWIG_IsOK(res1)) {
53192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53193 }
53194 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53195 if (obj1) {
53196 ecode2 = SWIG_AsVal_int(obj1, &val2);
53197 if (!SWIG_IsOK(ecode2)) {
53198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53199 }
53200 arg2 = static_cast< int >(val2);
53201 }
53202 if (obj2) {
53203 ecode3 = SWIG_AsVal_int(obj2, &val3);
53204 if (!SWIG_IsOK(ecode3)) {
53205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53206 }
53207 arg3 = static_cast< int >(val3);
53208 }
53209 {
53210 PyThreadState* __tstate = wxPyBeginAllowThreads();
53211 wxGBSpan_Set(arg1,arg2,arg3);
53212 wxPyEndAllowThreads(__tstate);
53213 if (PyErr_Occurred()) SWIG_fail;
53214 }
53215 resultobj = SWIG_Py_Void();
53216 return resultobj;
53217 fail:
53218 return NULL;
53219 }
53220
53221
53222 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53223 PyObject *resultobj = 0;
53224 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53225 PyObject *result = 0 ;
53226 void *argp1 = 0 ;
53227 int res1 = 0 ;
53228 PyObject *swig_obj[1] ;
53229
53230 if (!args) SWIG_fail;
53231 swig_obj[0] = args;
53232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53233 if (!SWIG_IsOK(res1)) {
53234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53235 }
53236 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53237 {
53238 PyThreadState* __tstate = wxPyBeginAllowThreads();
53239 result = (PyObject *)wxGBSpan_Get(arg1);
53240 wxPyEndAllowThreads(__tstate);
53241 if (PyErr_Occurred()) SWIG_fail;
53242 }
53243 resultobj = result;
53244 return resultobj;
53245 fail:
53246 return NULL;
53247 }
53248
53249
53250 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53251 PyObject *obj;
53252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53253 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53254 return SWIG_Py_Void();
53255 }
53256
53257 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53258 return SWIG_Python_InitShadowInstance(args);
53259 }
53260
53261 SWIGINTERN int DefaultSpan_set(PyObject *) {
53262 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53263 return 1;
53264 }
53265
53266
53267 SWIGINTERN PyObject *DefaultSpan_get(void) {
53268 PyObject *pyobj = 0;
53269
53270 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53271 return pyobj;
53272 }
53273
53274
53275 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53276 PyObject *resultobj = 0;
53277 wxGBSizerItem *result = 0 ;
53278
53279 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53280 {
53281 PyThreadState* __tstate = wxPyBeginAllowThreads();
53282 result = (wxGBSizerItem *)new wxGBSizerItem();
53283 wxPyEndAllowThreads(__tstate);
53284 if (PyErr_Occurred()) SWIG_fail;
53285 }
53286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53287 return resultobj;
53288 fail:
53289 return NULL;
53290 }
53291
53292
53293 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53294 PyObject *resultobj = 0;
53295 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53296 void *argp1 = 0 ;
53297 int res1 = 0 ;
53298 PyObject *swig_obj[1] ;
53299
53300 if (!args) SWIG_fail;
53301 swig_obj[0] = args;
53302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53303 if (!SWIG_IsOK(res1)) {
53304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53305 }
53306 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53307 {
53308 PyThreadState* __tstate = wxPyBeginAllowThreads();
53309 delete arg1;
53310
53311 wxPyEndAllowThreads(__tstate);
53312 if (PyErr_Occurred()) SWIG_fail;
53313 }
53314 resultobj = SWIG_Py_Void();
53315 return resultobj;
53316 fail:
53317 return NULL;
53318 }
53319
53320
53321 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53322 PyObject *resultobj = 0;
53323 wxWindow *arg1 = (wxWindow *) 0 ;
53324 wxGBPosition *arg2 = 0 ;
53325 wxGBSpan *arg3 = 0 ;
53326 int arg4 ;
53327 int arg5 ;
53328 PyObject *arg6 = (PyObject *) NULL ;
53329 wxGBSizerItem *result = 0 ;
53330 void *argp1 = 0 ;
53331 int res1 = 0 ;
53332 wxGBPosition temp2 ;
53333 wxGBSpan temp3 ;
53334 int val4 ;
53335 int ecode4 = 0 ;
53336 int val5 ;
53337 int ecode5 = 0 ;
53338 PyObject * obj0 = 0 ;
53339 PyObject * obj1 = 0 ;
53340 PyObject * obj2 = 0 ;
53341 PyObject * obj3 = 0 ;
53342 PyObject * obj4 = 0 ;
53343 PyObject * obj5 = 0 ;
53344 char * kwnames[] = {
53345 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53346 };
53347
53348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53350 if (!SWIG_IsOK(res1)) {
53351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53352 }
53353 arg1 = reinterpret_cast< wxWindow * >(argp1);
53354 {
53355 arg2 = &temp2;
53356 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53357 }
53358 {
53359 arg3 = &temp3;
53360 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53361 }
53362 ecode4 = SWIG_AsVal_int(obj3, &val4);
53363 if (!SWIG_IsOK(ecode4)) {
53364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53365 }
53366 arg4 = static_cast< int >(val4);
53367 ecode5 = SWIG_AsVal_int(obj4, &val5);
53368 if (!SWIG_IsOK(ecode5)) {
53369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53370 }
53371 arg5 = static_cast< int >(val5);
53372 if (obj5) {
53373 arg6 = obj5;
53374 }
53375 {
53376 PyThreadState* __tstate = wxPyBeginAllowThreads();
53377 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53378 wxPyEndAllowThreads(__tstate);
53379 if (PyErr_Occurred()) SWIG_fail;
53380 }
53381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53382 return resultobj;
53383 fail:
53384 return NULL;
53385 }
53386
53387
53388 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53389 PyObject *resultobj = 0;
53390 wxSizer *arg1 = (wxSizer *) 0 ;
53391 wxGBPosition *arg2 = 0 ;
53392 wxGBSpan *arg3 = 0 ;
53393 int arg4 ;
53394 int arg5 ;
53395 PyObject *arg6 = (PyObject *) NULL ;
53396 wxGBSizerItem *result = 0 ;
53397 int res1 = 0 ;
53398 wxGBPosition temp2 ;
53399 wxGBSpan temp3 ;
53400 int val4 ;
53401 int ecode4 = 0 ;
53402 int val5 ;
53403 int ecode5 = 0 ;
53404 PyObject * obj0 = 0 ;
53405 PyObject * obj1 = 0 ;
53406 PyObject * obj2 = 0 ;
53407 PyObject * obj3 = 0 ;
53408 PyObject * obj4 = 0 ;
53409 PyObject * obj5 = 0 ;
53410 char * kwnames[] = {
53411 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53412 };
53413
53414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53415 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53416 if (!SWIG_IsOK(res1)) {
53417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53418 }
53419 {
53420 arg2 = &temp2;
53421 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53422 }
53423 {
53424 arg3 = &temp3;
53425 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53426 }
53427 ecode4 = SWIG_AsVal_int(obj3, &val4);
53428 if (!SWIG_IsOK(ecode4)) {
53429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53430 }
53431 arg4 = static_cast< int >(val4);
53432 ecode5 = SWIG_AsVal_int(obj4, &val5);
53433 if (!SWIG_IsOK(ecode5)) {
53434 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53435 }
53436 arg5 = static_cast< int >(val5);
53437 if (obj5) {
53438 arg6 = obj5;
53439 }
53440 {
53441 PyThreadState* __tstate = wxPyBeginAllowThreads();
53442 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53443 wxPyEndAllowThreads(__tstate);
53444 if (PyErr_Occurred()) SWIG_fail;
53445 }
53446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53447 return resultobj;
53448 fail:
53449 return NULL;
53450 }
53451
53452
53453 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53454 PyObject *resultobj = 0;
53455 int arg1 ;
53456 int arg2 ;
53457 wxGBPosition *arg3 = 0 ;
53458 wxGBSpan *arg4 = 0 ;
53459 int arg5 ;
53460 int arg6 ;
53461 PyObject *arg7 = (PyObject *) NULL ;
53462 wxGBSizerItem *result = 0 ;
53463 int val1 ;
53464 int ecode1 = 0 ;
53465 int val2 ;
53466 int ecode2 = 0 ;
53467 wxGBPosition temp3 ;
53468 wxGBSpan temp4 ;
53469 int val5 ;
53470 int ecode5 = 0 ;
53471 int val6 ;
53472 int ecode6 = 0 ;
53473 PyObject * obj0 = 0 ;
53474 PyObject * obj1 = 0 ;
53475 PyObject * obj2 = 0 ;
53476 PyObject * obj3 = 0 ;
53477 PyObject * obj4 = 0 ;
53478 PyObject * obj5 = 0 ;
53479 PyObject * obj6 = 0 ;
53480 char * kwnames[] = {
53481 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53482 };
53483
53484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53485 ecode1 = SWIG_AsVal_int(obj0, &val1);
53486 if (!SWIG_IsOK(ecode1)) {
53487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53488 }
53489 arg1 = static_cast< int >(val1);
53490 ecode2 = SWIG_AsVal_int(obj1, &val2);
53491 if (!SWIG_IsOK(ecode2)) {
53492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53493 }
53494 arg2 = static_cast< int >(val2);
53495 {
53496 arg3 = &temp3;
53497 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53498 }
53499 {
53500 arg4 = &temp4;
53501 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53502 }
53503 ecode5 = SWIG_AsVal_int(obj4, &val5);
53504 if (!SWIG_IsOK(ecode5)) {
53505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53506 }
53507 arg5 = static_cast< int >(val5);
53508 ecode6 = SWIG_AsVal_int(obj5, &val6);
53509 if (!SWIG_IsOK(ecode6)) {
53510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53511 }
53512 arg6 = static_cast< int >(val6);
53513 if (obj6) {
53514 arg7 = obj6;
53515 }
53516 {
53517 PyThreadState* __tstate = wxPyBeginAllowThreads();
53518 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53519 wxPyEndAllowThreads(__tstate);
53520 if (PyErr_Occurred()) SWIG_fail;
53521 }
53522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53523 return resultobj;
53524 fail:
53525 return NULL;
53526 }
53527
53528
53529 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53530 PyObject *resultobj = 0;
53531 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53532 wxGBPosition result;
53533 void *argp1 = 0 ;
53534 int res1 = 0 ;
53535 PyObject *swig_obj[1] ;
53536
53537 if (!args) SWIG_fail;
53538 swig_obj[0] = args;
53539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53540 if (!SWIG_IsOK(res1)) {
53541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53542 }
53543 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53544 {
53545 PyThreadState* __tstate = wxPyBeginAllowThreads();
53546 result = ((wxGBSizerItem const *)arg1)->GetPos();
53547 wxPyEndAllowThreads(__tstate);
53548 if (PyErr_Occurred()) SWIG_fail;
53549 }
53550 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53551 return resultobj;
53552 fail:
53553 return NULL;
53554 }
53555
53556
53557 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53558 PyObject *resultobj = 0;
53559 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53560 wxGBSpan result;
53561 void *argp1 = 0 ;
53562 int res1 = 0 ;
53563 PyObject *swig_obj[1] ;
53564
53565 if (!args) SWIG_fail;
53566 swig_obj[0] = args;
53567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53568 if (!SWIG_IsOK(res1)) {
53569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53570 }
53571 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53572 {
53573 PyThreadState* __tstate = wxPyBeginAllowThreads();
53574 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53575 wxPyEndAllowThreads(__tstate);
53576 if (PyErr_Occurred()) SWIG_fail;
53577 }
53578 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53579 return resultobj;
53580 fail:
53581 return NULL;
53582 }
53583
53584
53585 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53586 PyObject *resultobj = 0;
53587 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53588 wxGBPosition *arg2 = 0 ;
53589 bool result;
53590 void *argp1 = 0 ;
53591 int res1 = 0 ;
53592 wxGBPosition temp2 ;
53593 PyObject * obj0 = 0 ;
53594 PyObject * obj1 = 0 ;
53595 char * kwnames[] = {
53596 (char *) "self",(char *) "pos", NULL
53597 };
53598
53599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53601 if (!SWIG_IsOK(res1)) {
53602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53603 }
53604 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53605 {
53606 arg2 = &temp2;
53607 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53608 }
53609 {
53610 PyThreadState* __tstate = wxPyBeginAllowThreads();
53611 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53612 wxPyEndAllowThreads(__tstate);
53613 if (PyErr_Occurred()) SWIG_fail;
53614 }
53615 {
53616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53617 }
53618 return resultobj;
53619 fail:
53620 return NULL;
53621 }
53622
53623
53624 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53625 PyObject *resultobj = 0;
53626 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53627 wxGBSpan *arg2 = 0 ;
53628 bool result;
53629 void *argp1 = 0 ;
53630 int res1 = 0 ;
53631 wxGBSpan temp2 ;
53632 PyObject * obj0 = 0 ;
53633 PyObject * obj1 = 0 ;
53634 char * kwnames[] = {
53635 (char *) "self",(char *) "span", NULL
53636 };
53637
53638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53640 if (!SWIG_IsOK(res1)) {
53641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53642 }
53643 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53644 {
53645 arg2 = &temp2;
53646 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53647 }
53648 {
53649 PyThreadState* __tstate = wxPyBeginAllowThreads();
53650 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53651 wxPyEndAllowThreads(__tstate);
53652 if (PyErr_Occurred()) SWIG_fail;
53653 }
53654 {
53655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53656 }
53657 return resultobj;
53658 fail:
53659 return NULL;
53660 }
53661
53662
53663 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53664 PyObject *resultobj = 0;
53665 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53666 wxGBSizerItem *arg2 = 0 ;
53667 bool result;
53668 void *argp1 = 0 ;
53669 int res1 = 0 ;
53670 void *argp2 = 0 ;
53671 int res2 = 0 ;
53672 PyObject * obj0 = 0 ;
53673 PyObject * obj1 = 0 ;
53674 char * kwnames[] = {
53675 (char *) "self",(char *) "other", NULL
53676 };
53677
53678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53680 if (!SWIG_IsOK(res1)) {
53681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53682 }
53683 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53685 if (!SWIG_IsOK(res2)) {
53686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53687 }
53688 if (!argp2) {
53689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53690 }
53691 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53692 {
53693 PyThreadState* __tstate = wxPyBeginAllowThreads();
53694 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53695 wxPyEndAllowThreads(__tstate);
53696 if (PyErr_Occurred()) SWIG_fail;
53697 }
53698 {
53699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53700 }
53701 return resultobj;
53702 fail:
53703 return NULL;
53704 }
53705
53706
53707 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53708 PyObject *resultobj = 0;
53709 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53710 wxGBPosition *arg2 = 0 ;
53711 wxGBSpan *arg3 = 0 ;
53712 bool result;
53713 void *argp1 = 0 ;
53714 int res1 = 0 ;
53715 wxGBPosition temp2 ;
53716 wxGBSpan temp3 ;
53717 PyObject * obj0 = 0 ;
53718 PyObject * obj1 = 0 ;
53719 PyObject * obj2 = 0 ;
53720 char * kwnames[] = {
53721 (char *) "self",(char *) "pos",(char *) "span", NULL
53722 };
53723
53724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53726 if (!SWIG_IsOK(res1)) {
53727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53728 }
53729 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53730 {
53731 arg2 = &temp2;
53732 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53733 }
53734 {
53735 arg3 = &temp3;
53736 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53737 }
53738 {
53739 PyThreadState* __tstate = wxPyBeginAllowThreads();
53740 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53741 wxPyEndAllowThreads(__tstate);
53742 if (PyErr_Occurred()) SWIG_fail;
53743 }
53744 {
53745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53746 }
53747 return resultobj;
53748 fail:
53749 return NULL;
53750 }
53751
53752
53753 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53754 PyObject *resultobj = 0;
53755 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53756 wxGBPosition result;
53757 void *argp1 = 0 ;
53758 int res1 = 0 ;
53759 PyObject *swig_obj[1] ;
53760
53761 if (!args) SWIG_fail;
53762 swig_obj[0] = args;
53763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53764 if (!SWIG_IsOK(res1)) {
53765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53766 }
53767 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53768 {
53769 PyThreadState* __tstate = wxPyBeginAllowThreads();
53770 result = wxGBSizerItem_GetEndPos(arg1);
53771 wxPyEndAllowThreads(__tstate);
53772 if (PyErr_Occurred()) SWIG_fail;
53773 }
53774 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53775 return resultobj;
53776 fail:
53777 return NULL;
53778 }
53779
53780
53781 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53782 PyObject *resultobj = 0;
53783 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53784 wxGridBagSizer *result = 0 ;
53785 void *argp1 = 0 ;
53786 int res1 = 0 ;
53787 PyObject *swig_obj[1] ;
53788
53789 if (!args) SWIG_fail;
53790 swig_obj[0] = args;
53791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53792 if (!SWIG_IsOK(res1)) {
53793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53794 }
53795 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53796 {
53797 PyThreadState* __tstate = wxPyBeginAllowThreads();
53798 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53799 wxPyEndAllowThreads(__tstate);
53800 if (PyErr_Occurred()) SWIG_fail;
53801 }
53802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53803 return resultobj;
53804 fail:
53805 return NULL;
53806 }
53807
53808
53809 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53810 PyObject *resultobj = 0;
53811 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53812 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53813 void *argp1 = 0 ;
53814 int res1 = 0 ;
53815 void *argp2 = 0 ;
53816 int res2 = 0 ;
53817 PyObject * obj0 = 0 ;
53818 PyObject * obj1 = 0 ;
53819 char * kwnames[] = {
53820 (char *) "self",(char *) "sizer", NULL
53821 };
53822
53823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53825 if (!SWIG_IsOK(res1)) {
53826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53827 }
53828 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53830 if (!SWIG_IsOK(res2)) {
53831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53832 }
53833 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53834 {
53835 PyThreadState* __tstate = wxPyBeginAllowThreads();
53836 (arg1)->SetGBSizer(arg2);
53837 wxPyEndAllowThreads(__tstate);
53838 if (PyErr_Occurred()) SWIG_fail;
53839 }
53840 resultobj = SWIG_Py_Void();
53841 return resultobj;
53842 fail:
53843 return NULL;
53844 }
53845
53846
53847 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53848 PyObject *obj;
53849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53850 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53851 return SWIG_Py_Void();
53852 }
53853
53854 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53855 return SWIG_Python_InitShadowInstance(args);
53856 }
53857
53858 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53859 PyObject *resultobj = 0;
53860 int arg1 = (int) 0 ;
53861 int arg2 = (int) 0 ;
53862 wxGridBagSizer *result = 0 ;
53863 int val1 ;
53864 int ecode1 = 0 ;
53865 int val2 ;
53866 int ecode2 = 0 ;
53867 PyObject * obj0 = 0 ;
53868 PyObject * obj1 = 0 ;
53869 char * kwnames[] = {
53870 (char *) "vgap",(char *) "hgap", NULL
53871 };
53872
53873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53874 if (obj0) {
53875 ecode1 = SWIG_AsVal_int(obj0, &val1);
53876 if (!SWIG_IsOK(ecode1)) {
53877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53878 }
53879 arg1 = static_cast< int >(val1);
53880 }
53881 if (obj1) {
53882 ecode2 = SWIG_AsVal_int(obj1, &val2);
53883 if (!SWIG_IsOK(ecode2)) {
53884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53885 }
53886 arg2 = static_cast< int >(val2);
53887 }
53888 {
53889 PyThreadState* __tstate = wxPyBeginAllowThreads();
53890 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53891 wxPyEndAllowThreads(__tstate);
53892 if (PyErr_Occurred()) SWIG_fail;
53893 }
53894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53895 return resultobj;
53896 fail:
53897 return NULL;
53898 }
53899
53900
53901 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53902 PyObject *resultobj = 0;
53903 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53904 PyObject *arg2 = (PyObject *) 0 ;
53905 wxGBPosition *arg3 = 0 ;
53906 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53907 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53908 int arg5 = (int) 0 ;
53909 int arg6 = (int) 0 ;
53910 PyObject *arg7 = (PyObject *) NULL ;
53911 wxGBSizerItem *result = 0 ;
53912 void *argp1 = 0 ;
53913 int res1 = 0 ;
53914 wxGBPosition temp3 ;
53915 wxGBSpan temp4 ;
53916 int val5 ;
53917 int ecode5 = 0 ;
53918 int val6 ;
53919 int ecode6 = 0 ;
53920 PyObject * obj0 = 0 ;
53921 PyObject * obj1 = 0 ;
53922 PyObject * obj2 = 0 ;
53923 PyObject * obj3 = 0 ;
53924 PyObject * obj4 = 0 ;
53925 PyObject * obj5 = 0 ;
53926 PyObject * obj6 = 0 ;
53927 char * kwnames[] = {
53928 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53929 };
53930
53931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53933 if (!SWIG_IsOK(res1)) {
53934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53935 }
53936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53937 arg2 = obj1;
53938 {
53939 arg3 = &temp3;
53940 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53941 }
53942 if (obj3) {
53943 {
53944 arg4 = &temp4;
53945 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53946 }
53947 }
53948 if (obj4) {
53949 ecode5 = SWIG_AsVal_int(obj4, &val5);
53950 if (!SWIG_IsOK(ecode5)) {
53951 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53952 }
53953 arg5 = static_cast< int >(val5);
53954 }
53955 if (obj5) {
53956 ecode6 = SWIG_AsVal_int(obj5, &val6);
53957 if (!SWIG_IsOK(ecode6)) {
53958 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53959 }
53960 arg6 = static_cast< int >(val6);
53961 }
53962 if (obj6) {
53963 arg7 = obj6;
53964 }
53965 {
53966 PyThreadState* __tstate = wxPyBeginAllowThreads();
53967 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53968 wxPyEndAllowThreads(__tstate);
53969 if (PyErr_Occurred()) SWIG_fail;
53970 }
53971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53972 return resultobj;
53973 fail:
53974 return NULL;
53975 }
53976
53977
53978 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53979 PyObject *resultobj = 0;
53980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53981 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53982 wxGBSizerItem *result = 0 ;
53983 void *argp1 = 0 ;
53984 int res1 = 0 ;
53985 int res2 = 0 ;
53986 PyObject * obj0 = 0 ;
53987 PyObject * obj1 = 0 ;
53988 char * kwnames[] = {
53989 (char *) "self",(char *) "item", NULL
53990 };
53991
53992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53994 if (!SWIG_IsOK(res1)) {
53995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53996 }
53997 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53998 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53999 if (!SWIG_IsOK(res2)) {
54000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54001 }
54002 {
54003 PyThreadState* __tstate = wxPyBeginAllowThreads();
54004 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54005 wxPyEndAllowThreads(__tstate);
54006 if (PyErr_Occurred()) SWIG_fail;
54007 }
54008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54009 return resultobj;
54010 fail:
54011 return NULL;
54012 }
54013
54014
54015 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54016 PyObject *resultobj = 0;
54017 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54018 int arg2 ;
54019 int arg3 ;
54020 wxSize result;
54021 void *argp1 = 0 ;
54022 int res1 = 0 ;
54023 int val2 ;
54024 int ecode2 = 0 ;
54025 int val3 ;
54026 int ecode3 = 0 ;
54027 PyObject * obj0 = 0 ;
54028 PyObject * obj1 = 0 ;
54029 PyObject * obj2 = 0 ;
54030 char * kwnames[] = {
54031 (char *) "self",(char *) "row",(char *) "col", NULL
54032 };
54033
54034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54036 if (!SWIG_IsOK(res1)) {
54037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54038 }
54039 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54040 ecode2 = SWIG_AsVal_int(obj1, &val2);
54041 if (!SWIG_IsOK(ecode2)) {
54042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54043 }
54044 arg2 = static_cast< int >(val2);
54045 ecode3 = SWIG_AsVal_int(obj2, &val3);
54046 if (!SWIG_IsOK(ecode3)) {
54047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54048 }
54049 arg3 = static_cast< int >(val3);
54050 {
54051 PyThreadState* __tstate = wxPyBeginAllowThreads();
54052 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54053 wxPyEndAllowThreads(__tstate);
54054 if (PyErr_Occurred()) SWIG_fail;
54055 }
54056 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54057 return resultobj;
54058 fail:
54059 return NULL;
54060 }
54061
54062
54063 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54064 PyObject *resultobj = 0;
54065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54066 wxSize result;
54067 void *argp1 = 0 ;
54068 int res1 = 0 ;
54069 PyObject *swig_obj[1] ;
54070
54071 if (!args) SWIG_fail;
54072 swig_obj[0] = args;
54073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54074 if (!SWIG_IsOK(res1)) {
54075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54076 }
54077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54078 {
54079 PyThreadState* __tstate = wxPyBeginAllowThreads();
54080 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54081 wxPyEndAllowThreads(__tstate);
54082 if (PyErr_Occurred()) SWIG_fail;
54083 }
54084 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54085 return resultobj;
54086 fail:
54087 return NULL;
54088 }
54089
54090
54091 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54092 PyObject *resultobj = 0;
54093 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54094 wxSize *arg2 = 0 ;
54095 void *argp1 = 0 ;
54096 int res1 = 0 ;
54097 wxSize temp2 ;
54098 PyObject * obj0 = 0 ;
54099 PyObject * obj1 = 0 ;
54100 char * kwnames[] = {
54101 (char *) "self",(char *) "sz", NULL
54102 };
54103
54104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54106 if (!SWIG_IsOK(res1)) {
54107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54108 }
54109 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54110 {
54111 arg2 = &temp2;
54112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54113 }
54114 {
54115 PyThreadState* __tstate = wxPyBeginAllowThreads();
54116 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54117 wxPyEndAllowThreads(__tstate);
54118 if (PyErr_Occurred()) SWIG_fail;
54119 }
54120 resultobj = SWIG_Py_Void();
54121 return resultobj;
54122 fail:
54123 return NULL;
54124 }
54125
54126
54127 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54128 PyObject *resultobj = 0;
54129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54130 wxWindow *arg2 = (wxWindow *) 0 ;
54131 wxGBPosition result;
54132 void *argp1 = 0 ;
54133 int res1 = 0 ;
54134 void *argp2 = 0 ;
54135 int res2 = 0 ;
54136
54137 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54139 if (!SWIG_IsOK(res1)) {
54140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54141 }
54142 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54143 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54144 if (!SWIG_IsOK(res2)) {
54145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54146 }
54147 arg2 = reinterpret_cast< wxWindow * >(argp2);
54148 {
54149 PyThreadState* __tstate = wxPyBeginAllowThreads();
54150 result = (arg1)->GetItemPosition(arg2);
54151 wxPyEndAllowThreads(__tstate);
54152 if (PyErr_Occurred()) SWIG_fail;
54153 }
54154 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54155 return resultobj;
54156 fail:
54157 return NULL;
54158 }
54159
54160
54161 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54162 PyObject *resultobj = 0;
54163 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54164 wxSizer *arg2 = (wxSizer *) 0 ;
54165 wxGBPosition result;
54166 void *argp1 = 0 ;
54167 int res1 = 0 ;
54168 void *argp2 = 0 ;
54169 int res2 = 0 ;
54170
54171 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54173 if (!SWIG_IsOK(res1)) {
54174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54175 }
54176 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54177 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54178 if (!SWIG_IsOK(res2)) {
54179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54180 }
54181 arg2 = reinterpret_cast< wxSizer * >(argp2);
54182 {
54183 PyThreadState* __tstate = wxPyBeginAllowThreads();
54184 result = (arg1)->GetItemPosition(arg2);
54185 wxPyEndAllowThreads(__tstate);
54186 if (PyErr_Occurred()) SWIG_fail;
54187 }
54188 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54189 return resultobj;
54190 fail:
54191 return NULL;
54192 }
54193
54194
54195 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54196 PyObject *resultobj = 0;
54197 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54198 size_t arg2 ;
54199 wxGBPosition result;
54200 void *argp1 = 0 ;
54201 int res1 = 0 ;
54202 size_t val2 ;
54203 int ecode2 = 0 ;
54204
54205 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54207 if (!SWIG_IsOK(res1)) {
54208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54209 }
54210 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54211 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54212 if (!SWIG_IsOK(ecode2)) {
54213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54214 }
54215 arg2 = static_cast< size_t >(val2);
54216 {
54217 PyThreadState* __tstate = wxPyBeginAllowThreads();
54218 result = (arg1)->GetItemPosition(arg2);
54219 wxPyEndAllowThreads(__tstate);
54220 if (PyErr_Occurred()) SWIG_fail;
54221 }
54222 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54223 return resultobj;
54224 fail:
54225 return NULL;
54226 }
54227
54228
54229 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54230 int argc;
54231 PyObject *argv[3];
54232
54233 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54234 --argc;
54235 if (argc == 2) {
54236 int _v = 0;
54237 {
54238 void *vptr = 0;
54239 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54240 _v = SWIG_CheckState(res);
54241 }
54242 if (!_v) goto check_1;
54243 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54244 }
54245 check_1:
54246
54247 if (argc == 2) {
54248 int _v = 0;
54249 {
54250 void *vptr = 0;
54251 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54252 _v = SWIG_CheckState(res);
54253 }
54254 if (!_v) goto check_2;
54255 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54256 }
54257 check_2:
54258
54259 if (argc == 2) {
54260 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54261 }
54262
54263 fail:
54264 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54265 return NULL;
54266 }
54267
54268
54269 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54270 PyObject *resultobj = 0;
54271 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54272 wxWindow *arg2 = (wxWindow *) 0 ;
54273 wxGBPosition *arg3 = 0 ;
54274 bool result;
54275 void *argp1 = 0 ;
54276 int res1 = 0 ;
54277 void *argp2 = 0 ;
54278 int res2 = 0 ;
54279 wxGBPosition temp3 ;
54280
54281 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54283 if (!SWIG_IsOK(res1)) {
54284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54285 }
54286 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54287 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54288 if (!SWIG_IsOK(res2)) {
54289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54290 }
54291 arg2 = reinterpret_cast< wxWindow * >(argp2);
54292 {
54293 arg3 = &temp3;
54294 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54295 }
54296 {
54297 PyThreadState* __tstate = wxPyBeginAllowThreads();
54298 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54299 wxPyEndAllowThreads(__tstate);
54300 if (PyErr_Occurred()) SWIG_fail;
54301 }
54302 {
54303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54304 }
54305 return resultobj;
54306 fail:
54307 return NULL;
54308 }
54309
54310
54311 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54312 PyObject *resultobj = 0;
54313 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54314 wxSizer *arg2 = (wxSizer *) 0 ;
54315 wxGBPosition *arg3 = 0 ;
54316 bool result;
54317 void *argp1 = 0 ;
54318 int res1 = 0 ;
54319 void *argp2 = 0 ;
54320 int res2 = 0 ;
54321 wxGBPosition temp3 ;
54322
54323 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54325 if (!SWIG_IsOK(res1)) {
54326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54327 }
54328 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54329 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54330 if (!SWIG_IsOK(res2)) {
54331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54332 }
54333 arg2 = reinterpret_cast< wxSizer * >(argp2);
54334 {
54335 arg3 = &temp3;
54336 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54337 }
54338 {
54339 PyThreadState* __tstate = wxPyBeginAllowThreads();
54340 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54341 wxPyEndAllowThreads(__tstate);
54342 if (PyErr_Occurred()) SWIG_fail;
54343 }
54344 {
54345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54346 }
54347 return resultobj;
54348 fail:
54349 return NULL;
54350 }
54351
54352
54353 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54354 PyObject *resultobj = 0;
54355 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54356 size_t arg2 ;
54357 wxGBPosition *arg3 = 0 ;
54358 bool result;
54359 void *argp1 = 0 ;
54360 int res1 = 0 ;
54361 size_t val2 ;
54362 int ecode2 = 0 ;
54363 wxGBPosition temp3 ;
54364
54365 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54367 if (!SWIG_IsOK(res1)) {
54368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54369 }
54370 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54371 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54372 if (!SWIG_IsOK(ecode2)) {
54373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54374 }
54375 arg2 = static_cast< size_t >(val2);
54376 {
54377 arg3 = &temp3;
54378 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54379 }
54380 {
54381 PyThreadState* __tstate = wxPyBeginAllowThreads();
54382 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54383 wxPyEndAllowThreads(__tstate);
54384 if (PyErr_Occurred()) SWIG_fail;
54385 }
54386 {
54387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54388 }
54389 return resultobj;
54390 fail:
54391 return NULL;
54392 }
54393
54394
54395 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54396 int argc;
54397 PyObject *argv[4];
54398
54399 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54400 --argc;
54401 if (argc == 3) {
54402 int _v = 0;
54403 {
54404 void *vptr = 0;
54405 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54406 _v = SWIG_CheckState(res);
54407 }
54408 if (!_v) goto check_1;
54409 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54410 }
54411 check_1:
54412
54413 if (argc == 3) {
54414 int _v = 0;
54415 {
54416 void *vptr = 0;
54417 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54418 _v = SWIG_CheckState(res);
54419 }
54420 if (!_v) goto check_2;
54421 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54422 }
54423 check_2:
54424
54425 if (argc == 3) {
54426 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54427 }
54428
54429 fail:
54430 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54431 return NULL;
54432 }
54433
54434
54435 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54436 PyObject *resultobj = 0;
54437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54438 wxWindow *arg2 = (wxWindow *) 0 ;
54439 wxGBSpan result;
54440 void *argp1 = 0 ;
54441 int res1 = 0 ;
54442 void *argp2 = 0 ;
54443 int res2 = 0 ;
54444
54445 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54447 if (!SWIG_IsOK(res1)) {
54448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54449 }
54450 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54451 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54452 if (!SWIG_IsOK(res2)) {
54453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54454 }
54455 arg2 = reinterpret_cast< wxWindow * >(argp2);
54456 {
54457 PyThreadState* __tstate = wxPyBeginAllowThreads();
54458 result = (arg1)->GetItemSpan(arg2);
54459 wxPyEndAllowThreads(__tstate);
54460 if (PyErr_Occurred()) SWIG_fail;
54461 }
54462 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54463 return resultobj;
54464 fail:
54465 return NULL;
54466 }
54467
54468
54469 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54470 PyObject *resultobj = 0;
54471 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54472 wxSizer *arg2 = (wxSizer *) 0 ;
54473 wxGBSpan result;
54474 void *argp1 = 0 ;
54475 int res1 = 0 ;
54476 void *argp2 = 0 ;
54477 int res2 = 0 ;
54478
54479 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54481 if (!SWIG_IsOK(res1)) {
54482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54483 }
54484 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54486 if (!SWIG_IsOK(res2)) {
54487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54488 }
54489 arg2 = reinterpret_cast< wxSizer * >(argp2);
54490 {
54491 PyThreadState* __tstate = wxPyBeginAllowThreads();
54492 result = (arg1)->GetItemSpan(arg2);
54493 wxPyEndAllowThreads(__tstate);
54494 if (PyErr_Occurred()) SWIG_fail;
54495 }
54496 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54497 return resultobj;
54498 fail:
54499 return NULL;
54500 }
54501
54502
54503 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54504 PyObject *resultobj = 0;
54505 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54506 size_t arg2 ;
54507 wxGBSpan result;
54508 void *argp1 = 0 ;
54509 int res1 = 0 ;
54510 size_t val2 ;
54511 int ecode2 = 0 ;
54512
54513 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54515 if (!SWIG_IsOK(res1)) {
54516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54517 }
54518 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54519 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54520 if (!SWIG_IsOK(ecode2)) {
54521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54522 }
54523 arg2 = static_cast< size_t >(val2);
54524 {
54525 PyThreadState* __tstate = wxPyBeginAllowThreads();
54526 result = (arg1)->GetItemSpan(arg2);
54527 wxPyEndAllowThreads(__tstate);
54528 if (PyErr_Occurred()) SWIG_fail;
54529 }
54530 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54531 return resultobj;
54532 fail:
54533 return NULL;
54534 }
54535
54536
54537 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54538 int argc;
54539 PyObject *argv[3];
54540
54541 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54542 --argc;
54543 if (argc == 2) {
54544 int _v = 0;
54545 {
54546 void *vptr = 0;
54547 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54548 _v = SWIG_CheckState(res);
54549 }
54550 if (!_v) goto check_1;
54551 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54552 }
54553 check_1:
54554
54555 if (argc == 2) {
54556 int _v = 0;
54557 {
54558 void *vptr = 0;
54559 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54560 _v = SWIG_CheckState(res);
54561 }
54562 if (!_v) goto check_2;
54563 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54564 }
54565 check_2:
54566
54567 if (argc == 2) {
54568 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54569 }
54570
54571 fail:
54572 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54573 return NULL;
54574 }
54575
54576
54577 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54578 PyObject *resultobj = 0;
54579 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54580 wxWindow *arg2 = (wxWindow *) 0 ;
54581 wxGBSpan *arg3 = 0 ;
54582 bool result;
54583 void *argp1 = 0 ;
54584 int res1 = 0 ;
54585 void *argp2 = 0 ;
54586 int res2 = 0 ;
54587 wxGBSpan temp3 ;
54588
54589 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54591 if (!SWIG_IsOK(res1)) {
54592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54593 }
54594 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54596 if (!SWIG_IsOK(res2)) {
54597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54598 }
54599 arg2 = reinterpret_cast< wxWindow * >(argp2);
54600 {
54601 arg3 = &temp3;
54602 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54603 }
54604 {
54605 PyThreadState* __tstate = wxPyBeginAllowThreads();
54606 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54607 wxPyEndAllowThreads(__tstate);
54608 if (PyErr_Occurred()) SWIG_fail;
54609 }
54610 {
54611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54612 }
54613 return resultobj;
54614 fail:
54615 return NULL;
54616 }
54617
54618
54619 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54620 PyObject *resultobj = 0;
54621 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54622 wxSizer *arg2 = (wxSizer *) 0 ;
54623 wxGBSpan *arg3 = 0 ;
54624 bool result;
54625 void *argp1 = 0 ;
54626 int res1 = 0 ;
54627 void *argp2 = 0 ;
54628 int res2 = 0 ;
54629 wxGBSpan temp3 ;
54630
54631 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54633 if (!SWIG_IsOK(res1)) {
54634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54635 }
54636 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54638 if (!SWIG_IsOK(res2)) {
54639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54640 }
54641 arg2 = reinterpret_cast< wxSizer * >(argp2);
54642 {
54643 arg3 = &temp3;
54644 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54645 }
54646 {
54647 PyThreadState* __tstate = wxPyBeginAllowThreads();
54648 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54649 wxPyEndAllowThreads(__tstate);
54650 if (PyErr_Occurred()) SWIG_fail;
54651 }
54652 {
54653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54654 }
54655 return resultobj;
54656 fail:
54657 return NULL;
54658 }
54659
54660
54661 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54662 PyObject *resultobj = 0;
54663 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54664 size_t arg2 ;
54665 wxGBSpan *arg3 = 0 ;
54666 bool result;
54667 void *argp1 = 0 ;
54668 int res1 = 0 ;
54669 size_t val2 ;
54670 int ecode2 = 0 ;
54671 wxGBSpan temp3 ;
54672
54673 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54675 if (!SWIG_IsOK(res1)) {
54676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54677 }
54678 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54679 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54680 if (!SWIG_IsOK(ecode2)) {
54681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54682 }
54683 arg2 = static_cast< size_t >(val2);
54684 {
54685 arg3 = &temp3;
54686 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54687 }
54688 {
54689 PyThreadState* __tstate = wxPyBeginAllowThreads();
54690 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54691 wxPyEndAllowThreads(__tstate);
54692 if (PyErr_Occurred()) SWIG_fail;
54693 }
54694 {
54695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54696 }
54697 return resultobj;
54698 fail:
54699 return NULL;
54700 }
54701
54702
54703 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54704 int argc;
54705 PyObject *argv[4];
54706
54707 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54708 --argc;
54709 if (argc == 3) {
54710 int _v = 0;
54711 {
54712 void *vptr = 0;
54713 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54714 _v = SWIG_CheckState(res);
54715 }
54716 if (!_v) goto check_1;
54717 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54718 }
54719 check_1:
54720
54721 if (argc == 3) {
54722 int _v = 0;
54723 {
54724 void *vptr = 0;
54725 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54726 _v = SWIG_CheckState(res);
54727 }
54728 if (!_v) goto check_2;
54729 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54730 }
54731 check_2:
54732
54733 if (argc == 3) {
54734 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54735 }
54736
54737 fail:
54738 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54739 return NULL;
54740 }
54741
54742
54743 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54744 PyObject *resultobj = 0;
54745 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54746 wxWindow *arg2 = (wxWindow *) 0 ;
54747 wxGBSizerItem *result = 0 ;
54748 void *argp1 = 0 ;
54749 int res1 = 0 ;
54750 void *argp2 = 0 ;
54751 int res2 = 0 ;
54752
54753 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54755 if (!SWIG_IsOK(res1)) {
54756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54757 }
54758 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54759 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54760 if (!SWIG_IsOK(res2)) {
54761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54762 }
54763 arg2 = reinterpret_cast< wxWindow * >(argp2);
54764 {
54765 PyThreadState* __tstate = wxPyBeginAllowThreads();
54766 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54767 wxPyEndAllowThreads(__tstate);
54768 if (PyErr_Occurred()) SWIG_fail;
54769 }
54770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54771 return resultobj;
54772 fail:
54773 return NULL;
54774 }
54775
54776
54777 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54778 PyObject *resultobj = 0;
54779 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54780 wxSizer *arg2 = (wxSizer *) 0 ;
54781 wxGBSizerItem *result = 0 ;
54782 void *argp1 = 0 ;
54783 int res1 = 0 ;
54784 void *argp2 = 0 ;
54785 int res2 = 0 ;
54786
54787 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54789 if (!SWIG_IsOK(res1)) {
54790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54791 }
54792 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54794 if (!SWIG_IsOK(res2)) {
54795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54796 }
54797 arg2 = reinterpret_cast< wxSizer * >(argp2);
54798 {
54799 PyThreadState* __tstate = wxPyBeginAllowThreads();
54800 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54801 wxPyEndAllowThreads(__tstate);
54802 if (PyErr_Occurred()) SWIG_fail;
54803 }
54804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54805 return resultobj;
54806 fail:
54807 return NULL;
54808 }
54809
54810
54811 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54812 int argc;
54813 PyObject *argv[3];
54814
54815 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54816 --argc;
54817 if (argc == 2) {
54818 int _v = 0;
54819 {
54820 void *vptr = 0;
54821 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54822 _v = SWIG_CheckState(res);
54823 }
54824 if (!_v) goto check_1;
54825 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54826 }
54827 check_1:
54828
54829 if (argc == 2) {
54830 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54831 }
54832
54833 fail:
54834 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54835 return NULL;
54836 }
54837
54838
54839 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54840 PyObject *resultobj = 0;
54841 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54842 wxGBPosition *arg2 = 0 ;
54843 wxGBSizerItem *result = 0 ;
54844 void *argp1 = 0 ;
54845 int res1 = 0 ;
54846 wxGBPosition temp2 ;
54847 PyObject * obj0 = 0 ;
54848 PyObject * obj1 = 0 ;
54849 char * kwnames[] = {
54850 (char *) "self",(char *) "pos", NULL
54851 };
54852
54853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54855 if (!SWIG_IsOK(res1)) {
54856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54857 }
54858 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54859 {
54860 arg2 = &temp2;
54861 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54862 }
54863 {
54864 PyThreadState* __tstate = wxPyBeginAllowThreads();
54865 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54866 wxPyEndAllowThreads(__tstate);
54867 if (PyErr_Occurred()) SWIG_fail;
54868 }
54869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54870 return resultobj;
54871 fail:
54872 return NULL;
54873 }
54874
54875
54876 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54877 PyObject *resultobj = 0;
54878 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54879 wxPoint *arg2 = 0 ;
54880 wxGBSizerItem *result = 0 ;
54881 void *argp1 = 0 ;
54882 int res1 = 0 ;
54883 wxPoint temp2 ;
54884 PyObject * obj0 = 0 ;
54885 PyObject * obj1 = 0 ;
54886 char * kwnames[] = {
54887 (char *) "self",(char *) "pt", NULL
54888 };
54889
54890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54892 if (!SWIG_IsOK(res1)) {
54893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54894 }
54895 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54896 {
54897 arg2 = &temp2;
54898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54899 }
54900 {
54901 PyThreadState* __tstate = wxPyBeginAllowThreads();
54902 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54903 wxPyEndAllowThreads(__tstate);
54904 if (PyErr_Occurred()) SWIG_fail;
54905 }
54906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54907 return resultobj;
54908 fail:
54909 return NULL;
54910 }
54911
54912
54913 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54914 PyObject *resultobj = 0;
54915 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54916 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54917 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54918 bool result;
54919 void *argp1 = 0 ;
54920 int res1 = 0 ;
54921 void *argp2 = 0 ;
54922 int res2 = 0 ;
54923 void *argp3 = 0 ;
54924 int res3 = 0 ;
54925 PyObject * obj0 = 0 ;
54926 PyObject * obj1 = 0 ;
54927 PyObject * obj2 = 0 ;
54928 char * kwnames[] = {
54929 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54930 };
54931
54932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54934 if (!SWIG_IsOK(res1)) {
54935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54936 }
54937 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54939 if (!SWIG_IsOK(res2)) {
54940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54941 }
54942 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54943 if (obj2) {
54944 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54945 if (!SWIG_IsOK(res3)) {
54946 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54947 }
54948 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54949 }
54950 {
54951 PyThreadState* __tstate = wxPyBeginAllowThreads();
54952 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54953 wxPyEndAllowThreads(__tstate);
54954 if (PyErr_Occurred()) SWIG_fail;
54955 }
54956 {
54957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54958 }
54959 return resultobj;
54960 fail:
54961 return NULL;
54962 }
54963
54964
54965 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54966 PyObject *resultobj = 0;
54967 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54968 wxGBPosition *arg2 = 0 ;
54969 wxGBSpan *arg3 = 0 ;
54970 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54971 bool result;
54972 void *argp1 = 0 ;
54973 int res1 = 0 ;
54974 wxGBPosition temp2 ;
54975 wxGBSpan temp3 ;
54976 void *argp4 = 0 ;
54977 int res4 = 0 ;
54978 PyObject * obj0 = 0 ;
54979 PyObject * obj1 = 0 ;
54980 PyObject * obj2 = 0 ;
54981 PyObject * obj3 = 0 ;
54982 char * kwnames[] = {
54983 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54984 };
54985
54986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54988 if (!SWIG_IsOK(res1)) {
54989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54990 }
54991 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54992 {
54993 arg2 = &temp2;
54994 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54995 }
54996 {
54997 arg3 = &temp3;
54998 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54999 }
55000 if (obj3) {
55001 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55002 if (!SWIG_IsOK(res4)) {
55003 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55004 }
55005 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55006 }
55007 {
55008 PyThreadState* __tstate = wxPyBeginAllowThreads();
55009 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55010 wxPyEndAllowThreads(__tstate);
55011 if (PyErr_Occurred()) SWIG_fail;
55012 }
55013 {
55014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55015 }
55016 return resultobj;
55017 fail:
55018 return NULL;
55019 }
55020
55021
55022 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55023 PyObject *obj;
55024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55025 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55026 return SWIG_Py_Void();
55027 }
55028
55029 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55030 return SWIG_Python_InitShadowInstance(args);
55031 }
55032
55033 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55034 PyObject *resultobj = 0;
55035 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55036 wxRelationship arg2 ;
55037 wxWindow *arg3 = (wxWindow *) 0 ;
55038 wxEdge arg4 ;
55039 int arg5 = (int) 0 ;
55040 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55041 void *argp1 = 0 ;
55042 int res1 = 0 ;
55043 int val2 ;
55044 int ecode2 = 0 ;
55045 void *argp3 = 0 ;
55046 int res3 = 0 ;
55047 int val4 ;
55048 int ecode4 = 0 ;
55049 int val5 ;
55050 int ecode5 = 0 ;
55051 int val6 ;
55052 int ecode6 = 0 ;
55053 PyObject * obj0 = 0 ;
55054 PyObject * obj1 = 0 ;
55055 PyObject * obj2 = 0 ;
55056 PyObject * obj3 = 0 ;
55057 PyObject * obj4 = 0 ;
55058 PyObject * obj5 = 0 ;
55059 char * kwnames[] = {
55060 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55061 };
55062
55063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55065 if (!SWIG_IsOK(res1)) {
55066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55067 }
55068 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55069 ecode2 = SWIG_AsVal_int(obj1, &val2);
55070 if (!SWIG_IsOK(ecode2)) {
55071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55072 }
55073 arg2 = static_cast< wxRelationship >(val2);
55074 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55075 if (!SWIG_IsOK(res3)) {
55076 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55077 }
55078 arg3 = reinterpret_cast< wxWindow * >(argp3);
55079 ecode4 = SWIG_AsVal_int(obj3, &val4);
55080 if (!SWIG_IsOK(ecode4)) {
55081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55082 }
55083 arg4 = static_cast< wxEdge >(val4);
55084 if (obj4) {
55085 ecode5 = SWIG_AsVal_int(obj4, &val5);
55086 if (!SWIG_IsOK(ecode5)) {
55087 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55088 }
55089 arg5 = static_cast< int >(val5);
55090 }
55091 if (obj5) {
55092 ecode6 = SWIG_AsVal_int(obj5, &val6);
55093 if (!SWIG_IsOK(ecode6)) {
55094 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55095 }
55096 arg6 = static_cast< int >(val6);
55097 }
55098 {
55099 PyThreadState* __tstate = wxPyBeginAllowThreads();
55100 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55101 wxPyEndAllowThreads(__tstate);
55102 if (PyErr_Occurred()) SWIG_fail;
55103 }
55104 resultobj = SWIG_Py_Void();
55105 return resultobj;
55106 fail:
55107 return NULL;
55108 }
55109
55110
55111 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55112 PyObject *resultobj = 0;
55113 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55114 wxWindow *arg2 = (wxWindow *) 0 ;
55115 int arg3 = (int) 0 ;
55116 void *argp1 = 0 ;
55117 int res1 = 0 ;
55118 void *argp2 = 0 ;
55119 int res2 = 0 ;
55120 int val3 ;
55121 int ecode3 = 0 ;
55122 PyObject * obj0 = 0 ;
55123 PyObject * obj1 = 0 ;
55124 PyObject * obj2 = 0 ;
55125 char * kwnames[] = {
55126 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55127 };
55128
55129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55131 if (!SWIG_IsOK(res1)) {
55132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55133 }
55134 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55136 if (!SWIG_IsOK(res2)) {
55137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55138 }
55139 arg2 = reinterpret_cast< wxWindow * >(argp2);
55140 if (obj2) {
55141 ecode3 = SWIG_AsVal_int(obj2, &val3);
55142 if (!SWIG_IsOK(ecode3)) {
55143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55144 }
55145 arg3 = static_cast< int >(val3);
55146 }
55147 {
55148 PyThreadState* __tstate = wxPyBeginAllowThreads();
55149 (arg1)->LeftOf(arg2,arg3);
55150 wxPyEndAllowThreads(__tstate);
55151 if (PyErr_Occurred()) SWIG_fail;
55152 }
55153 resultobj = SWIG_Py_Void();
55154 return resultobj;
55155 fail:
55156 return NULL;
55157 }
55158
55159
55160 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55161 PyObject *resultobj = 0;
55162 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55163 wxWindow *arg2 = (wxWindow *) 0 ;
55164 int arg3 = (int) 0 ;
55165 void *argp1 = 0 ;
55166 int res1 = 0 ;
55167 void *argp2 = 0 ;
55168 int res2 = 0 ;
55169 int val3 ;
55170 int ecode3 = 0 ;
55171 PyObject * obj0 = 0 ;
55172 PyObject * obj1 = 0 ;
55173 PyObject * obj2 = 0 ;
55174 char * kwnames[] = {
55175 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55176 };
55177
55178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55180 if (!SWIG_IsOK(res1)) {
55181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55182 }
55183 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55185 if (!SWIG_IsOK(res2)) {
55186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55187 }
55188 arg2 = reinterpret_cast< wxWindow * >(argp2);
55189 if (obj2) {
55190 ecode3 = SWIG_AsVal_int(obj2, &val3);
55191 if (!SWIG_IsOK(ecode3)) {
55192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55193 }
55194 arg3 = static_cast< int >(val3);
55195 }
55196 {
55197 PyThreadState* __tstate = wxPyBeginAllowThreads();
55198 (arg1)->RightOf(arg2,arg3);
55199 wxPyEndAllowThreads(__tstate);
55200 if (PyErr_Occurred()) SWIG_fail;
55201 }
55202 resultobj = SWIG_Py_Void();
55203 return resultobj;
55204 fail:
55205 return NULL;
55206 }
55207
55208
55209 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55210 PyObject *resultobj = 0;
55211 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55212 wxWindow *arg2 = (wxWindow *) 0 ;
55213 int arg3 = (int) 0 ;
55214 void *argp1 = 0 ;
55215 int res1 = 0 ;
55216 void *argp2 = 0 ;
55217 int res2 = 0 ;
55218 int val3 ;
55219 int ecode3 = 0 ;
55220 PyObject * obj0 = 0 ;
55221 PyObject * obj1 = 0 ;
55222 PyObject * obj2 = 0 ;
55223 char * kwnames[] = {
55224 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55225 };
55226
55227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55229 if (!SWIG_IsOK(res1)) {
55230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55231 }
55232 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55234 if (!SWIG_IsOK(res2)) {
55235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55236 }
55237 arg2 = reinterpret_cast< wxWindow * >(argp2);
55238 if (obj2) {
55239 ecode3 = SWIG_AsVal_int(obj2, &val3);
55240 if (!SWIG_IsOK(ecode3)) {
55241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55242 }
55243 arg3 = static_cast< int >(val3);
55244 }
55245 {
55246 PyThreadState* __tstate = wxPyBeginAllowThreads();
55247 (arg1)->Above(arg2,arg3);
55248 wxPyEndAllowThreads(__tstate);
55249 if (PyErr_Occurred()) SWIG_fail;
55250 }
55251 resultobj = SWIG_Py_Void();
55252 return resultobj;
55253 fail:
55254 return NULL;
55255 }
55256
55257
55258 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55259 PyObject *resultobj = 0;
55260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55261 wxWindow *arg2 = (wxWindow *) 0 ;
55262 int arg3 = (int) 0 ;
55263 void *argp1 = 0 ;
55264 int res1 = 0 ;
55265 void *argp2 = 0 ;
55266 int res2 = 0 ;
55267 int val3 ;
55268 int ecode3 = 0 ;
55269 PyObject * obj0 = 0 ;
55270 PyObject * obj1 = 0 ;
55271 PyObject * obj2 = 0 ;
55272 char * kwnames[] = {
55273 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55274 };
55275
55276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55278 if (!SWIG_IsOK(res1)) {
55279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55280 }
55281 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55283 if (!SWIG_IsOK(res2)) {
55284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55285 }
55286 arg2 = reinterpret_cast< wxWindow * >(argp2);
55287 if (obj2) {
55288 ecode3 = SWIG_AsVal_int(obj2, &val3);
55289 if (!SWIG_IsOK(ecode3)) {
55290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55291 }
55292 arg3 = static_cast< int >(val3);
55293 }
55294 {
55295 PyThreadState* __tstate = wxPyBeginAllowThreads();
55296 (arg1)->Below(arg2,arg3);
55297 wxPyEndAllowThreads(__tstate);
55298 if (PyErr_Occurred()) SWIG_fail;
55299 }
55300 resultobj = SWIG_Py_Void();
55301 return resultobj;
55302 fail:
55303 return NULL;
55304 }
55305
55306
55307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55308 PyObject *resultobj = 0;
55309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55310 wxWindow *arg2 = (wxWindow *) 0 ;
55311 wxEdge arg3 ;
55312 int arg4 = (int) 0 ;
55313 void *argp1 = 0 ;
55314 int res1 = 0 ;
55315 void *argp2 = 0 ;
55316 int res2 = 0 ;
55317 int val3 ;
55318 int ecode3 = 0 ;
55319 int val4 ;
55320 int ecode4 = 0 ;
55321 PyObject * obj0 = 0 ;
55322 PyObject * obj1 = 0 ;
55323 PyObject * obj2 = 0 ;
55324 PyObject * obj3 = 0 ;
55325 char * kwnames[] = {
55326 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55327 };
55328
55329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55331 if (!SWIG_IsOK(res1)) {
55332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55333 }
55334 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55336 if (!SWIG_IsOK(res2)) {
55337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55338 }
55339 arg2 = reinterpret_cast< wxWindow * >(argp2);
55340 ecode3 = SWIG_AsVal_int(obj2, &val3);
55341 if (!SWIG_IsOK(ecode3)) {
55342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55343 }
55344 arg3 = static_cast< wxEdge >(val3);
55345 if (obj3) {
55346 ecode4 = SWIG_AsVal_int(obj3, &val4);
55347 if (!SWIG_IsOK(ecode4)) {
55348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55349 }
55350 arg4 = static_cast< int >(val4);
55351 }
55352 {
55353 PyThreadState* __tstate = wxPyBeginAllowThreads();
55354 (arg1)->SameAs(arg2,arg3,arg4);
55355 wxPyEndAllowThreads(__tstate);
55356 if (PyErr_Occurred()) SWIG_fail;
55357 }
55358 resultobj = SWIG_Py_Void();
55359 return resultobj;
55360 fail:
55361 return NULL;
55362 }
55363
55364
55365 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55366 PyObject *resultobj = 0;
55367 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55368 wxWindow *arg2 = (wxWindow *) 0 ;
55369 wxEdge arg3 ;
55370 int arg4 ;
55371 void *argp1 = 0 ;
55372 int res1 = 0 ;
55373 void *argp2 = 0 ;
55374 int res2 = 0 ;
55375 int val3 ;
55376 int ecode3 = 0 ;
55377 int val4 ;
55378 int ecode4 = 0 ;
55379 PyObject * obj0 = 0 ;
55380 PyObject * obj1 = 0 ;
55381 PyObject * obj2 = 0 ;
55382 PyObject * obj3 = 0 ;
55383 char * kwnames[] = {
55384 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55385 };
55386
55387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55389 if (!SWIG_IsOK(res1)) {
55390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55391 }
55392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55394 if (!SWIG_IsOK(res2)) {
55395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55396 }
55397 arg2 = reinterpret_cast< wxWindow * >(argp2);
55398 ecode3 = SWIG_AsVal_int(obj2, &val3);
55399 if (!SWIG_IsOK(ecode3)) {
55400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55401 }
55402 arg3 = static_cast< wxEdge >(val3);
55403 ecode4 = SWIG_AsVal_int(obj3, &val4);
55404 if (!SWIG_IsOK(ecode4)) {
55405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55406 }
55407 arg4 = static_cast< int >(val4);
55408 {
55409 PyThreadState* __tstate = wxPyBeginAllowThreads();
55410 (arg1)->PercentOf(arg2,arg3,arg4);
55411 wxPyEndAllowThreads(__tstate);
55412 if (PyErr_Occurred()) SWIG_fail;
55413 }
55414 resultobj = SWIG_Py_Void();
55415 return resultobj;
55416 fail:
55417 return NULL;
55418 }
55419
55420
55421 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55422 PyObject *resultobj = 0;
55423 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55424 int arg2 ;
55425 void *argp1 = 0 ;
55426 int res1 = 0 ;
55427 int val2 ;
55428 int ecode2 = 0 ;
55429 PyObject * obj0 = 0 ;
55430 PyObject * obj1 = 0 ;
55431 char * kwnames[] = {
55432 (char *) "self",(char *) "val", NULL
55433 };
55434
55435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55437 if (!SWIG_IsOK(res1)) {
55438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55439 }
55440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55441 ecode2 = SWIG_AsVal_int(obj1, &val2);
55442 if (!SWIG_IsOK(ecode2)) {
55443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55444 }
55445 arg2 = static_cast< int >(val2);
55446 {
55447 PyThreadState* __tstate = wxPyBeginAllowThreads();
55448 (arg1)->Absolute(arg2);
55449 wxPyEndAllowThreads(__tstate);
55450 if (PyErr_Occurred()) SWIG_fail;
55451 }
55452 resultobj = SWIG_Py_Void();
55453 return resultobj;
55454 fail:
55455 return NULL;
55456 }
55457
55458
55459 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55460 PyObject *resultobj = 0;
55461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55462 void *argp1 = 0 ;
55463 int res1 = 0 ;
55464 PyObject *swig_obj[1] ;
55465
55466 if (!args) SWIG_fail;
55467 swig_obj[0] = args;
55468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55469 if (!SWIG_IsOK(res1)) {
55470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55471 }
55472 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55473 {
55474 PyThreadState* __tstate = wxPyBeginAllowThreads();
55475 (arg1)->Unconstrained();
55476 wxPyEndAllowThreads(__tstate);
55477 if (PyErr_Occurred()) SWIG_fail;
55478 }
55479 resultobj = SWIG_Py_Void();
55480 return resultobj;
55481 fail:
55482 return NULL;
55483 }
55484
55485
55486 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55487 PyObject *resultobj = 0;
55488 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55489 void *argp1 = 0 ;
55490 int res1 = 0 ;
55491 PyObject *swig_obj[1] ;
55492
55493 if (!args) SWIG_fail;
55494 swig_obj[0] = args;
55495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55496 if (!SWIG_IsOK(res1)) {
55497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55498 }
55499 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55500 {
55501 PyThreadState* __tstate = wxPyBeginAllowThreads();
55502 (arg1)->AsIs();
55503 wxPyEndAllowThreads(__tstate);
55504 if (PyErr_Occurred()) SWIG_fail;
55505 }
55506 resultobj = SWIG_Py_Void();
55507 return resultobj;
55508 fail:
55509 return NULL;
55510 }
55511
55512
55513 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55514 PyObject *resultobj = 0;
55515 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55516 wxWindow *result = 0 ;
55517 void *argp1 = 0 ;
55518 int res1 = 0 ;
55519 PyObject *swig_obj[1] ;
55520
55521 if (!args) SWIG_fail;
55522 swig_obj[0] = args;
55523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55524 if (!SWIG_IsOK(res1)) {
55525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55526 }
55527 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55528 {
55529 PyThreadState* __tstate = wxPyBeginAllowThreads();
55530 result = (wxWindow *)(arg1)->GetOtherWindow();
55531 wxPyEndAllowThreads(__tstate);
55532 if (PyErr_Occurred()) SWIG_fail;
55533 }
55534 {
55535 resultobj = wxPyMake_wxObject(result, 0);
55536 }
55537 return resultobj;
55538 fail:
55539 return NULL;
55540 }
55541
55542
55543 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55544 PyObject *resultobj = 0;
55545 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55546 wxEdge result;
55547 void *argp1 = 0 ;
55548 int res1 = 0 ;
55549 PyObject *swig_obj[1] ;
55550
55551 if (!args) SWIG_fail;
55552 swig_obj[0] = args;
55553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55554 if (!SWIG_IsOK(res1)) {
55555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55556 }
55557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55558 {
55559 PyThreadState* __tstate = wxPyBeginAllowThreads();
55560 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55561 wxPyEndAllowThreads(__tstate);
55562 if (PyErr_Occurred()) SWIG_fail;
55563 }
55564 resultobj = SWIG_From_int(static_cast< int >(result));
55565 return resultobj;
55566 fail:
55567 return NULL;
55568 }
55569
55570
55571 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55572 PyObject *resultobj = 0;
55573 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55574 wxEdge arg2 ;
55575 void *argp1 = 0 ;
55576 int res1 = 0 ;
55577 int val2 ;
55578 int ecode2 = 0 ;
55579 PyObject * obj0 = 0 ;
55580 PyObject * obj1 = 0 ;
55581 char * kwnames[] = {
55582 (char *) "self",(char *) "which", NULL
55583 };
55584
55585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55587 if (!SWIG_IsOK(res1)) {
55588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55589 }
55590 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55591 ecode2 = SWIG_AsVal_int(obj1, &val2);
55592 if (!SWIG_IsOK(ecode2)) {
55593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55594 }
55595 arg2 = static_cast< wxEdge >(val2);
55596 {
55597 PyThreadState* __tstate = wxPyBeginAllowThreads();
55598 (arg1)->SetEdge(arg2);
55599 wxPyEndAllowThreads(__tstate);
55600 if (PyErr_Occurred()) SWIG_fail;
55601 }
55602 resultobj = SWIG_Py_Void();
55603 return resultobj;
55604 fail:
55605 return NULL;
55606 }
55607
55608
55609 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55610 PyObject *resultobj = 0;
55611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55612 int arg2 ;
55613 void *argp1 = 0 ;
55614 int res1 = 0 ;
55615 int val2 ;
55616 int ecode2 = 0 ;
55617 PyObject * obj0 = 0 ;
55618 PyObject * obj1 = 0 ;
55619 char * kwnames[] = {
55620 (char *) "self",(char *) "v", NULL
55621 };
55622
55623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55625 if (!SWIG_IsOK(res1)) {
55626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55627 }
55628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55629 ecode2 = SWIG_AsVal_int(obj1, &val2);
55630 if (!SWIG_IsOK(ecode2)) {
55631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55632 }
55633 arg2 = static_cast< int >(val2);
55634 {
55635 PyThreadState* __tstate = wxPyBeginAllowThreads();
55636 (arg1)->SetValue(arg2);
55637 wxPyEndAllowThreads(__tstate);
55638 if (PyErr_Occurred()) SWIG_fail;
55639 }
55640 resultobj = SWIG_Py_Void();
55641 return resultobj;
55642 fail:
55643 return NULL;
55644 }
55645
55646
55647 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55648 PyObject *resultobj = 0;
55649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55650 int result;
55651 void *argp1 = 0 ;
55652 int res1 = 0 ;
55653 PyObject *swig_obj[1] ;
55654
55655 if (!args) SWIG_fail;
55656 swig_obj[0] = args;
55657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55658 if (!SWIG_IsOK(res1)) {
55659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55660 }
55661 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55662 {
55663 PyThreadState* __tstate = wxPyBeginAllowThreads();
55664 result = (int)(arg1)->GetMargin();
55665 wxPyEndAllowThreads(__tstate);
55666 if (PyErr_Occurred()) SWIG_fail;
55667 }
55668 resultobj = SWIG_From_int(static_cast< int >(result));
55669 return resultobj;
55670 fail:
55671 return NULL;
55672 }
55673
55674
55675 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55676 PyObject *resultobj = 0;
55677 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55678 int arg2 ;
55679 void *argp1 = 0 ;
55680 int res1 = 0 ;
55681 int val2 ;
55682 int ecode2 = 0 ;
55683 PyObject * obj0 = 0 ;
55684 PyObject * obj1 = 0 ;
55685 char * kwnames[] = {
55686 (char *) "self",(char *) "m", NULL
55687 };
55688
55689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55691 if (!SWIG_IsOK(res1)) {
55692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55693 }
55694 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55695 ecode2 = SWIG_AsVal_int(obj1, &val2);
55696 if (!SWIG_IsOK(ecode2)) {
55697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55698 }
55699 arg2 = static_cast< int >(val2);
55700 {
55701 PyThreadState* __tstate = wxPyBeginAllowThreads();
55702 (arg1)->SetMargin(arg2);
55703 wxPyEndAllowThreads(__tstate);
55704 if (PyErr_Occurred()) SWIG_fail;
55705 }
55706 resultobj = SWIG_Py_Void();
55707 return resultobj;
55708 fail:
55709 return NULL;
55710 }
55711
55712
55713 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55714 PyObject *resultobj = 0;
55715 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55716 int result;
55717 void *argp1 = 0 ;
55718 int res1 = 0 ;
55719 PyObject *swig_obj[1] ;
55720
55721 if (!args) SWIG_fail;
55722 swig_obj[0] = args;
55723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55724 if (!SWIG_IsOK(res1)) {
55725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55726 }
55727 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55728 {
55729 PyThreadState* __tstate = wxPyBeginAllowThreads();
55730 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55731 wxPyEndAllowThreads(__tstate);
55732 if (PyErr_Occurred()) SWIG_fail;
55733 }
55734 resultobj = SWIG_From_int(static_cast< int >(result));
55735 return resultobj;
55736 fail:
55737 return NULL;
55738 }
55739
55740
55741 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55742 PyObject *resultobj = 0;
55743 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55744 int result;
55745 void *argp1 = 0 ;
55746 int res1 = 0 ;
55747 PyObject *swig_obj[1] ;
55748
55749 if (!args) SWIG_fail;
55750 swig_obj[0] = args;
55751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55752 if (!SWIG_IsOK(res1)) {
55753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55754 }
55755 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55756 {
55757 PyThreadState* __tstate = wxPyBeginAllowThreads();
55758 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55759 wxPyEndAllowThreads(__tstate);
55760 if (PyErr_Occurred()) SWIG_fail;
55761 }
55762 resultobj = SWIG_From_int(static_cast< int >(result));
55763 return resultobj;
55764 fail:
55765 return NULL;
55766 }
55767
55768
55769 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55770 PyObject *resultobj = 0;
55771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55772 int result;
55773 void *argp1 = 0 ;
55774 int res1 = 0 ;
55775 PyObject *swig_obj[1] ;
55776
55777 if (!args) SWIG_fail;
55778 swig_obj[0] = args;
55779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55780 if (!SWIG_IsOK(res1)) {
55781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55782 }
55783 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55784 {
55785 PyThreadState* __tstate = wxPyBeginAllowThreads();
55786 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55787 wxPyEndAllowThreads(__tstate);
55788 if (PyErr_Occurred()) SWIG_fail;
55789 }
55790 resultobj = SWIG_From_int(static_cast< int >(result));
55791 return resultobj;
55792 fail:
55793 return NULL;
55794 }
55795
55796
55797 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55798 PyObject *resultobj = 0;
55799 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55800 bool result;
55801 void *argp1 = 0 ;
55802 int res1 = 0 ;
55803 PyObject *swig_obj[1] ;
55804
55805 if (!args) SWIG_fail;
55806 swig_obj[0] = args;
55807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55808 if (!SWIG_IsOK(res1)) {
55809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55810 }
55811 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55812 {
55813 PyThreadState* __tstate = wxPyBeginAllowThreads();
55814 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55815 wxPyEndAllowThreads(__tstate);
55816 if (PyErr_Occurred()) SWIG_fail;
55817 }
55818 {
55819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55820 }
55821 return resultobj;
55822 fail:
55823 return NULL;
55824 }
55825
55826
55827 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55828 PyObject *resultobj = 0;
55829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55830 bool arg2 ;
55831 void *argp1 = 0 ;
55832 int res1 = 0 ;
55833 bool val2 ;
55834 int ecode2 = 0 ;
55835 PyObject * obj0 = 0 ;
55836 PyObject * obj1 = 0 ;
55837 char * kwnames[] = {
55838 (char *) "self",(char *) "d", NULL
55839 };
55840
55841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55843 if (!SWIG_IsOK(res1)) {
55844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55845 }
55846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55848 if (!SWIG_IsOK(ecode2)) {
55849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55850 }
55851 arg2 = static_cast< bool >(val2);
55852 {
55853 PyThreadState* __tstate = wxPyBeginAllowThreads();
55854 (arg1)->SetDone(arg2);
55855 wxPyEndAllowThreads(__tstate);
55856 if (PyErr_Occurred()) SWIG_fail;
55857 }
55858 resultobj = SWIG_Py_Void();
55859 return resultobj;
55860 fail:
55861 return NULL;
55862 }
55863
55864
55865 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55866 PyObject *resultobj = 0;
55867 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55868 wxRelationship result;
55869 void *argp1 = 0 ;
55870 int res1 = 0 ;
55871 PyObject *swig_obj[1] ;
55872
55873 if (!args) SWIG_fail;
55874 swig_obj[0] = args;
55875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55876 if (!SWIG_IsOK(res1)) {
55877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55878 }
55879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55880 {
55881 PyThreadState* __tstate = wxPyBeginAllowThreads();
55882 result = (wxRelationship)(arg1)->GetRelationship();
55883 wxPyEndAllowThreads(__tstate);
55884 if (PyErr_Occurred()) SWIG_fail;
55885 }
55886 resultobj = SWIG_From_int(static_cast< int >(result));
55887 return resultobj;
55888 fail:
55889 return NULL;
55890 }
55891
55892
55893 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55894 PyObject *resultobj = 0;
55895 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55896 wxRelationship arg2 ;
55897 void *argp1 = 0 ;
55898 int res1 = 0 ;
55899 int val2 ;
55900 int ecode2 = 0 ;
55901 PyObject * obj0 = 0 ;
55902 PyObject * obj1 = 0 ;
55903 char * kwnames[] = {
55904 (char *) "self",(char *) "r", NULL
55905 };
55906
55907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55909 if (!SWIG_IsOK(res1)) {
55910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55911 }
55912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55913 ecode2 = SWIG_AsVal_int(obj1, &val2);
55914 if (!SWIG_IsOK(ecode2)) {
55915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55916 }
55917 arg2 = static_cast< wxRelationship >(val2);
55918 {
55919 PyThreadState* __tstate = wxPyBeginAllowThreads();
55920 (arg1)->SetRelationship(arg2);
55921 wxPyEndAllowThreads(__tstate);
55922 if (PyErr_Occurred()) SWIG_fail;
55923 }
55924 resultobj = SWIG_Py_Void();
55925 return resultobj;
55926 fail:
55927 return NULL;
55928 }
55929
55930
55931 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55932 PyObject *resultobj = 0;
55933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55934 wxWindow *arg2 = (wxWindow *) 0 ;
55935 bool result;
55936 void *argp1 = 0 ;
55937 int res1 = 0 ;
55938 void *argp2 = 0 ;
55939 int res2 = 0 ;
55940 PyObject * obj0 = 0 ;
55941 PyObject * obj1 = 0 ;
55942 char * kwnames[] = {
55943 (char *) "self",(char *) "otherW", NULL
55944 };
55945
55946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55948 if (!SWIG_IsOK(res1)) {
55949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55950 }
55951 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55953 if (!SWIG_IsOK(res2)) {
55954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55955 }
55956 arg2 = reinterpret_cast< wxWindow * >(argp2);
55957 {
55958 PyThreadState* __tstate = wxPyBeginAllowThreads();
55959 result = (bool)(arg1)->ResetIfWin(arg2);
55960 wxPyEndAllowThreads(__tstate);
55961 if (PyErr_Occurred()) SWIG_fail;
55962 }
55963 {
55964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55965 }
55966 return resultobj;
55967 fail:
55968 return NULL;
55969 }
55970
55971
55972 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55973 PyObject *resultobj = 0;
55974 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55975 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55976 wxWindow *arg3 = (wxWindow *) 0 ;
55977 bool result;
55978 void *argp1 = 0 ;
55979 int res1 = 0 ;
55980 void *argp2 = 0 ;
55981 int res2 = 0 ;
55982 void *argp3 = 0 ;
55983 int res3 = 0 ;
55984 PyObject * obj0 = 0 ;
55985 PyObject * obj1 = 0 ;
55986 PyObject * obj2 = 0 ;
55987 char * kwnames[] = {
55988 (char *) "self",(char *) "constraints",(char *) "win", NULL
55989 };
55990
55991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55993 if (!SWIG_IsOK(res1)) {
55994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55995 }
55996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55998 if (!SWIG_IsOK(res2)) {
55999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56000 }
56001 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56003 if (!SWIG_IsOK(res3)) {
56004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56005 }
56006 arg3 = reinterpret_cast< wxWindow * >(argp3);
56007 {
56008 PyThreadState* __tstate = wxPyBeginAllowThreads();
56009 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56010 wxPyEndAllowThreads(__tstate);
56011 if (PyErr_Occurred()) SWIG_fail;
56012 }
56013 {
56014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56015 }
56016 return resultobj;
56017 fail:
56018 return NULL;
56019 }
56020
56021
56022 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56023 PyObject *resultobj = 0;
56024 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56025 wxEdge arg2 ;
56026 wxWindow *arg3 = (wxWindow *) 0 ;
56027 wxWindow *arg4 = (wxWindow *) 0 ;
56028 int result;
56029 void *argp1 = 0 ;
56030 int res1 = 0 ;
56031 int val2 ;
56032 int ecode2 = 0 ;
56033 void *argp3 = 0 ;
56034 int res3 = 0 ;
56035 void *argp4 = 0 ;
56036 int res4 = 0 ;
56037 PyObject * obj0 = 0 ;
56038 PyObject * obj1 = 0 ;
56039 PyObject * obj2 = 0 ;
56040 PyObject * obj3 = 0 ;
56041 char * kwnames[] = {
56042 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56043 };
56044
56045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56047 if (!SWIG_IsOK(res1)) {
56048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56049 }
56050 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56051 ecode2 = SWIG_AsVal_int(obj1, &val2);
56052 if (!SWIG_IsOK(ecode2)) {
56053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56054 }
56055 arg2 = static_cast< wxEdge >(val2);
56056 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56057 if (!SWIG_IsOK(res3)) {
56058 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56059 }
56060 arg3 = reinterpret_cast< wxWindow * >(argp3);
56061 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56062 if (!SWIG_IsOK(res4)) {
56063 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56064 }
56065 arg4 = reinterpret_cast< wxWindow * >(argp4);
56066 {
56067 PyThreadState* __tstate = wxPyBeginAllowThreads();
56068 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56069 wxPyEndAllowThreads(__tstate);
56070 if (PyErr_Occurred()) SWIG_fail;
56071 }
56072 resultobj = SWIG_From_int(static_cast< int >(result));
56073 return resultobj;
56074 fail:
56075 return NULL;
56076 }
56077
56078
56079 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56080 PyObject *obj;
56081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56082 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56083 return SWIG_Py_Void();
56084 }
56085
56086 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56087 PyObject *resultobj = 0;
56088 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56089 wxIndividualLayoutConstraint *result = 0 ;
56090 void *argp1 = 0 ;
56091 int res1 = 0 ;
56092 PyObject *swig_obj[1] ;
56093
56094 if (!args) SWIG_fail;
56095 swig_obj[0] = args;
56096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56097 if (!SWIG_IsOK(res1)) {
56098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56099 }
56100 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56101 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56103 return resultobj;
56104 fail:
56105 return NULL;
56106 }
56107
56108
56109 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56110 PyObject *resultobj = 0;
56111 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56112 wxIndividualLayoutConstraint *result = 0 ;
56113 void *argp1 = 0 ;
56114 int res1 = 0 ;
56115 PyObject *swig_obj[1] ;
56116
56117 if (!args) SWIG_fail;
56118 swig_obj[0] = args;
56119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56120 if (!SWIG_IsOK(res1)) {
56121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56122 }
56123 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56124 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56126 return resultobj;
56127 fail:
56128 return NULL;
56129 }
56130
56131
56132 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56133 PyObject *resultobj = 0;
56134 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56135 wxIndividualLayoutConstraint *result = 0 ;
56136 void *argp1 = 0 ;
56137 int res1 = 0 ;
56138 PyObject *swig_obj[1] ;
56139
56140 if (!args) SWIG_fail;
56141 swig_obj[0] = args;
56142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56143 if (!SWIG_IsOK(res1)) {
56144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56145 }
56146 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56147 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56149 return resultobj;
56150 fail:
56151 return NULL;
56152 }
56153
56154
56155 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56156 PyObject *resultobj = 0;
56157 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56158 wxIndividualLayoutConstraint *result = 0 ;
56159 void *argp1 = 0 ;
56160 int res1 = 0 ;
56161 PyObject *swig_obj[1] ;
56162
56163 if (!args) SWIG_fail;
56164 swig_obj[0] = args;
56165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56166 if (!SWIG_IsOK(res1)) {
56167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56168 }
56169 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56170 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56172 return resultobj;
56173 fail:
56174 return NULL;
56175 }
56176
56177
56178 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56179 PyObject *resultobj = 0;
56180 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56181 wxIndividualLayoutConstraint *result = 0 ;
56182 void *argp1 = 0 ;
56183 int res1 = 0 ;
56184 PyObject *swig_obj[1] ;
56185
56186 if (!args) SWIG_fail;
56187 swig_obj[0] = args;
56188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56189 if (!SWIG_IsOK(res1)) {
56190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56191 }
56192 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56193 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56195 return resultobj;
56196 fail:
56197 return NULL;
56198 }
56199
56200
56201 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56202 PyObject *resultobj = 0;
56203 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56204 wxIndividualLayoutConstraint *result = 0 ;
56205 void *argp1 = 0 ;
56206 int res1 = 0 ;
56207 PyObject *swig_obj[1] ;
56208
56209 if (!args) SWIG_fail;
56210 swig_obj[0] = args;
56211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56212 if (!SWIG_IsOK(res1)) {
56213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56214 }
56215 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56216 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56218 return resultobj;
56219 fail:
56220 return NULL;
56221 }
56222
56223
56224 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56225 PyObject *resultobj = 0;
56226 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56227 wxIndividualLayoutConstraint *result = 0 ;
56228 void *argp1 = 0 ;
56229 int res1 = 0 ;
56230 PyObject *swig_obj[1] ;
56231
56232 if (!args) SWIG_fail;
56233 swig_obj[0] = args;
56234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56235 if (!SWIG_IsOK(res1)) {
56236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56237 }
56238 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56239 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56241 return resultobj;
56242 fail:
56243 return NULL;
56244 }
56245
56246
56247 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56248 PyObject *resultobj = 0;
56249 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56250 wxIndividualLayoutConstraint *result = 0 ;
56251 void *argp1 = 0 ;
56252 int res1 = 0 ;
56253 PyObject *swig_obj[1] ;
56254
56255 if (!args) SWIG_fail;
56256 swig_obj[0] = args;
56257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56258 if (!SWIG_IsOK(res1)) {
56259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56260 }
56261 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56262 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56264 return resultobj;
56265 fail:
56266 return NULL;
56267 }
56268
56269
56270 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56271 PyObject *resultobj = 0;
56272 wxLayoutConstraints *result = 0 ;
56273
56274 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56275 {
56276 PyThreadState* __tstate = wxPyBeginAllowThreads();
56277 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56278 wxPyEndAllowThreads(__tstate);
56279 if (PyErr_Occurred()) SWIG_fail;
56280 }
56281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56282 return resultobj;
56283 fail:
56284 return NULL;
56285 }
56286
56287
56288 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56289 PyObject *resultobj = 0;
56290 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56291 void *argp1 = 0 ;
56292 int res1 = 0 ;
56293 PyObject *swig_obj[1] ;
56294
56295 if (!args) SWIG_fail;
56296 swig_obj[0] = args;
56297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56298 if (!SWIG_IsOK(res1)) {
56299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56300 }
56301 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56302 {
56303 PyThreadState* __tstate = wxPyBeginAllowThreads();
56304 delete arg1;
56305
56306 wxPyEndAllowThreads(__tstate);
56307 if (PyErr_Occurred()) SWIG_fail;
56308 }
56309 resultobj = SWIG_Py_Void();
56310 return resultobj;
56311 fail:
56312 return NULL;
56313 }
56314
56315
56316 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56317 PyObject *resultobj = 0;
56318 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56319 wxWindow *arg2 = (wxWindow *) 0 ;
56320 int *arg3 = (int *) 0 ;
56321 bool result;
56322 void *argp1 = 0 ;
56323 int res1 = 0 ;
56324 void *argp2 = 0 ;
56325 int res2 = 0 ;
56326 int temp3 ;
56327 int res3 = SWIG_TMPOBJ ;
56328 PyObject * obj0 = 0 ;
56329 PyObject * obj1 = 0 ;
56330 char * kwnames[] = {
56331 (char *) "self",(char *) "win", NULL
56332 };
56333
56334 arg3 = &temp3;
56335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56337 if (!SWIG_IsOK(res1)) {
56338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56339 }
56340 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56342 if (!SWIG_IsOK(res2)) {
56343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56344 }
56345 arg2 = reinterpret_cast< wxWindow * >(argp2);
56346 {
56347 PyThreadState* __tstate = wxPyBeginAllowThreads();
56348 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56349 wxPyEndAllowThreads(__tstate);
56350 if (PyErr_Occurred()) SWIG_fail;
56351 }
56352 {
56353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56354 }
56355 if (SWIG_IsTmpObj(res3)) {
56356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56357 } else {
56358 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56360 }
56361 return resultobj;
56362 fail:
56363 return NULL;
56364 }
56365
56366
56367 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56368 PyObject *resultobj = 0;
56369 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56370 bool result;
56371 void *argp1 = 0 ;
56372 int res1 = 0 ;
56373 PyObject *swig_obj[1] ;
56374
56375 if (!args) SWIG_fail;
56376 swig_obj[0] = args;
56377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56378 if (!SWIG_IsOK(res1)) {
56379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56380 }
56381 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56382 {
56383 PyThreadState* __tstate = wxPyBeginAllowThreads();
56384 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56385 wxPyEndAllowThreads(__tstate);
56386 if (PyErr_Occurred()) SWIG_fail;
56387 }
56388 {
56389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56390 }
56391 return resultobj;
56392 fail:
56393 return NULL;
56394 }
56395
56396
56397 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56398 PyObject *obj;
56399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56400 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56401 return SWIG_Py_Void();
56402 }
56403
56404 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56405 return SWIG_Python_InitShadowInstance(args);
56406 }
56407
56408 static PyMethodDef SwigMethods[] = {
56409 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56410 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56411 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56412 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56413 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56414 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56415 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56416 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56417 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56418 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56420 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56425 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56433 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56434 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56435 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56437 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56438 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56439 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56440 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56441 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56442 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56443 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56445 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56451 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56452 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56453 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56454 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56455 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56456 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56457 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56459 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56467 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56468 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56469 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56474 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56475 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56477 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56479 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56481 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56483 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56485 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56487 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56488 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56490 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56492 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56494 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56496 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56497 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56498 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56499 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56519 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56520 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56521 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56522 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56523 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56524 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56525 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56526 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56528 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56529 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56530 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56535 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56536 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56537 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56538 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56539 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56546 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56553 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56554 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56555 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56556 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56558 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56559 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56560 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56562 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56563 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56564 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56565 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56568 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56570 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56571 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56574 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56577 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56578 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56580 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56583 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56586 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56589 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56595 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56597 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56606 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56609 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56610 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56611 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56612 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56613 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56614 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56615 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56616 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56618 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56619 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56620 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56622 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56623 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56624 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56625 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56630 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56631 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56632 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56633 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56634 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56635 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56638 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56639 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56640 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56642 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56643 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56645 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56646 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56647 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56648 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56649 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56650 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56651 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56652 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56653 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56654 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56655 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56656 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56661 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56667 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56668 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56669 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56670 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56672 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56675 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56678 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56681 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56682 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56683 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56686 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56687 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56688 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56692 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56693 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56694 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56698 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56703 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56704 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56705 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56706 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56707 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56708 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56709 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56716 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56717 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56719 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56720 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56721 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56727 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56728 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56730 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56731 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56732 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56733 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56734 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56735 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56736 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56737 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56739 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56740 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56741 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56742 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56743 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56744 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56745 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56746 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56748 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56757 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56774 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56775 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56790 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56791 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56792 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56793 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56796 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56798 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56800 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56802 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56804 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56807 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56808 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56809 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56810 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56812 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56829 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56830 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56836 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56837 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56839 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56840 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56841 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56842 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56843 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56844 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56845 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56846 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56847 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56848 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56849 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56850 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56851 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56852 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56853 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56854 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56855 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56856 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56857 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56858 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56859 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56860 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56861 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56862 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56863 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56864 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56865 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56866 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56867 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56868 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56869 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56870 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56871 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56873 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56874 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56875 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56876 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56879 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56883 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56885 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56886 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56890 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56891 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56892 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56893 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56894 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56895 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56896 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56898 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56900 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56902 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56904 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56905 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56906 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56908 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56909 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56910 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56911 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56912 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56913 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56915 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56916 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56917 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56919 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56920 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56921 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56922 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56923 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56925 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56927 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56928 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56930 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56931 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56932 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56934 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56935 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56936 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56937 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56938 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56940 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56941 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56944 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56945 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56946 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56947 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56948 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56951 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56952 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56954 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56959 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56960 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56961 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56962 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56963 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56964 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56965 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56966 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56967 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56968 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56969 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56970 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56971 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56972 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56973 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56974 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56975 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56976 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56977 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56978 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56979 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56980 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56981 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56982 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56983 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56985 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56986 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56987 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56988 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56989 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56990 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56991 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56992 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56993 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56994 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56995 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56996 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56997 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56998 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56999 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57000 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57001 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57002 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57003 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57004 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57005 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57006 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57007 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57008 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57009 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57010 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57011 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57012 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57013 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57014 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57015 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57016 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57017 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57018 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57019 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57021 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57022 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57023 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57024 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57026 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57027 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57028 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57029 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57030 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57031 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57032 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57033 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57034 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57035 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57036 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57037 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57038 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57039 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57040 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57041 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57042 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57043 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57044 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57045 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57046 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57047 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57048 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57049 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57050 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57051 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57052 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57053 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57054 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57055 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57056 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57057 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57058 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57059 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57060 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57061 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57062 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57063 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57064 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57065 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57066 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57067 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57068 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57069 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57070 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57071 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57072 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57073 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57074 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57076 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57077 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57079 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57080 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57081 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57083 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57084 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57085 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57086 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57087 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57089 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57090 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57091 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57093 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57094 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57095 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57096 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57098 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57099 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57100 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57101 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57102 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57106 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57107 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57109 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57110 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57111 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57112 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57113 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57116 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57118 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57120 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57125 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57129 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57130 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57131 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57133 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57134 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57135 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57136 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57137 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57138 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57140 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57141 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57142 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57143 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57144 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57145 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57146 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57147 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57152 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57153 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57155 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57157 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57158 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57159 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57160 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57161 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57162 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57164 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57165 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57166 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57167 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57168 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57169 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57170 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57171 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57172 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57174 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57175 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57176 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57177 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57180 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57181 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57182 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57183 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57184 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57186 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57188 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57191 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57193 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57194 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57195 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57196 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57197 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57198 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57200 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57204 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57205 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57206 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57207 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57208 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57210 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57212 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57214 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57215 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57216 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57217 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57218 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57220 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57222 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57223 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57224 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57226 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57228 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57229 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57230 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57231 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57232 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57234 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57235 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57236 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57237 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57239 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57241 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57243 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57245 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57246 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57248 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57249 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57250 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57251 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57252 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57253 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57254 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57255 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57256 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57258 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57259 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57260 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57262 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57263 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57264 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57266 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57268 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57269 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57270 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57271 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57272 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57273 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57279 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57280 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57281 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57282 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57283 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57284 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57285 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57286 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57287 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57288 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57290 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57291 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57293 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57294 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57295 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57296 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57298 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57299 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57300 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57301 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57303 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57304 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57306 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57307 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57308 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57310 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57313 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57314 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57315 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57316 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57317 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57319 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57320 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57321 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57322 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57323 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57324 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57325 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57327 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57328 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57329 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57330 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57331 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57332 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57333 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57334 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57335 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57336 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57338 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57341 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57342 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57343 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57344 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57345 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57347 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57349 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57351 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57352 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57355 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57357 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57365 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57366 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57370 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57371 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57372 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57373 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57374 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57375 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57376 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57377 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57378 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57379 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57380 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57381 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57382 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57383 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57384 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
57386 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57389 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57390 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57395 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57396 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57399 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57400 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57401 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57402 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57405 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57406 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57407 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57409 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57410 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57411 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57412 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57413 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57414 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57416 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57418 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57420 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57423 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57424 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57425 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57426 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57427 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57428 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57432 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57433 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57434 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57435 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57436 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57442 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57448 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57449 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57450 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57451 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57452 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57454 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57464 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57465 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57466 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57467 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57470 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57471 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57472 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57473 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57474 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57476 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57477 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57478 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57482 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57488 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57489 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57490 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57491 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57493 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57494 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57496 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57499 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57501 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57502 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57503 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57512 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57516 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57517 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57519 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57529 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57530 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57531 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57532 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57536 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57539 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57541 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57544 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57546 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57547 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57550 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57552 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57553 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57554 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57555 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57557 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57558 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57563 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57564 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57565 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57567 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57568 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57569 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57571 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57573 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57574 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57575 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57577 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57578 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57581 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57589 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57596 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57604 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57607 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57608 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57621 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57623 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57625 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57626 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57628 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57630 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57631 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57633 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57634 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57635 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57639 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57658 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57659 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57661 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57662 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57664 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57665 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57666 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57668 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57669 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57672 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57673 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57675 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57676 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57678 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57681 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57682 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57684 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57686 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57688 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57689 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57691 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57692 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57695 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57697 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57699 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57701 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57704 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57706 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57707 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57708 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57710 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57711 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57712 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57714 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57716 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57717 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57720 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57721 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57725 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57729 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57730 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57732 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57736 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57738 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57740 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57741 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57742 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57743 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57747 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57748 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57749 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57750 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57752 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57753 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57758 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57759 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57760 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57761 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57762 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57764 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57766 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57768 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57769 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57771 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57773 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57776 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57777 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57778 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57780 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57781 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57782 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57795 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57801 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57802 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57803 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57804 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57805 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57806 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57812 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57813 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57817 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57818 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57820 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57821 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57823 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57825 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57826 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57828 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57829 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57830 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57836 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57837 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57838 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57839 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57840 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57841 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57848 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57850 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57851 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57852 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57853 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57854 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57855 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57857 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57861 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57862 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57863 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57864 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57865 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57866 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57867 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57869 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57870 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57871 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57877 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57878 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57879 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57881 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57882 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57883 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57889 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57890 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57891 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57892 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57893 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57897 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57898 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57903 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57904 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57906 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57907 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57912 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57914 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57915 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57916 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57917 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57918 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57923 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57924 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57933 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57934 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57935 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57936 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57939 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57941 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57942 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57943 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57944 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57946 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57951 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57952 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57953 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57954 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57955 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57956 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57957 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57958 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57959 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57960 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57961 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57963 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57964 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57965 { NULL, NULL, 0, NULL }
57966 };
57967
57968
57969 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57970
57971 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57972 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57973 }
57974 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57975 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57976 }
57977 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57978 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57979 }
57980 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57981 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57982 }
57983 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57984 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57985 }
57986 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57987 return (void *)((wxSizer *) ((wxGridSizer *) x));
57988 }
57989 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57990 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57991 }
57992 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57993 return (void *)((wxSizer *) ((wxPySizer *) x));
57994 }
57995 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57996 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57997 }
57998 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57999 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58000 }
58001 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58002 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58003 }
58004 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58005 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58006 }
58007 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58008 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58009 }
58010 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58011 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58012 }
58013 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58014 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58015 }
58016 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58017 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58018 }
58019 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58020 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58021 }
58022 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58023 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58024 }
58025 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58026 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58027 }
58028 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58029 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58030 }
58031 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58032 return (void *)((wxEvent *) ((wxPyEvent *) x));
58033 }
58034 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58035 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58036 }
58037 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58039 }
58040 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58041 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58042 }
58043 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58044 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58045 }
58046 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58047 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58048 }
58049 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58050 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58051 }
58052 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58053 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58054 }
58055 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58056 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58057 }
58058 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58059 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58060 }
58061 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58062 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58063 }
58064 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58065 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58066 }
58067 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58068 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58069 }
58070 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58071 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58072 }
58073 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58074 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58075 }
58076 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58077 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58078 }
58079 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58080 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58081 }
58082 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58083 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58084 }
58085 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58086 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58087 }
58088 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58089 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58090 }
58091 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58092 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58093 }
58094 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58095 return (void *)((wxEvent *) ((wxShowEvent *) x));
58096 }
58097 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58098 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58099 }
58100 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58101 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58102 }
58103 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58104 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58105 }
58106 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58107 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58108 }
58109 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58110 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58111 }
58112 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58113 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58114 }
58115 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58116 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58117 }
58118 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58119 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58120 }
58121 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58122 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58123 }
58124 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58125 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58126 }
58127 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58128 return (void *)((wxControl *) ((wxControlWithItems *) x));
58129 }
58130 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58131 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58132 }
58133 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58134 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58135 }
58136 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58137 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58138 }
58139 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58140 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58141 }
58142 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58143 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58144 }
58145 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58146 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58147 }
58148 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58149 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58150 }
58151 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58152 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58153 }
58154 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58155 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58156 }
58157 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58158 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58159 }
58160 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58161 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58162 }
58163 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58164 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58165 }
58166 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58167 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58168 }
58169 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58170 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58171 }
58172 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58173 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58174 }
58175 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58176 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58177 }
58178 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58179 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58180 }
58181 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58182 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58183 }
58184 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58185 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58186 }
58187 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58188 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58189 }
58190 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58191 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58192 }
58193 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58194 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58195 }
58196 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58197 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58198 }
58199 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58200 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58201 }
58202 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58203 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58204 }
58205 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58206 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58207 }
58208 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58209 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58210 }
58211 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58212 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58213 }
58214 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58215 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58216 }
58217 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58218 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58219 }
58220 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58221 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58222 }
58223 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58224 return (void *)((wxObject *) ((wxSizerItem *) x));
58225 }
58226 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58227 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58228 }
58229 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58230 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58231 }
58232 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58233 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58234 }
58235 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58236 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58237 }
58238 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58239 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58240 }
58241 static void *_p_wxSizerTo_p_wxObject(void *x) {
58242 return (void *)((wxObject *) ((wxSizer *) x));
58243 }
58244 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58245 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58246 }
58247 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58248 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58249 }
58250 static void *_p_wxEventTo_p_wxObject(void *x) {
58251 return (void *)((wxObject *) ((wxEvent *) x));
58252 }
58253 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58254 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58255 }
58256 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58257 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58258 }
58259 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58260 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58261 }
58262 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58263 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58264 }
58265 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58266 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58267 }
58268 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58269 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58270 }
58271 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58272 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58273 }
58274 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58275 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58276 }
58277 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58278 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58279 }
58280 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58281 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58282 }
58283 static void *_p_wxControlTo_p_wxObject(void *x) {
58284 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58285 }
58286 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58287 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58288 }
58289 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58290 return (void *)((wxObject *) ((wxFSFile *) x));
58291 }
58292 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58293 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58294 }
58295 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58296 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58297 }
58298 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58299 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58300 }
58301 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58302 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58303 }
58304 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58305 return (void *)((wxObject *) ((wxMenuItem *) x));
58306 }
58307 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58308 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58309 }
58310 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58311 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58312 }
58313 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58314 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58315 }
58316 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58317 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58318 }
58319 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58320 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58321 }
58322 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58323 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58324 }
58325 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58326 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58327 }
58328 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58329 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58330 }
58331 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58332 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58333 }
58334 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58335 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58336 }
58337 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58338 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58339 }
58340 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58341 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58342 }
58343 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58344 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58345 }
58346 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58347 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58348 }
58349 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58350 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58351 }
58352 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58353 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58354 }
58355 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58356 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58357 }
58358 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58359 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58360 }
58361 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58362 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58363 }
58364 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58365 return (void *)((wxObject *) ((wxImageHandler *) x));
58366 }
58367 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58368 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58369 }
58370 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58371 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58372 }
58373 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58374 return (void *)((wxObject *) ((wxEvtHandler *) x));
58375 }
58376 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58377 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58378 }
58379 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58380 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58381 }
58382 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58383 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58384 }
58385 static void *_p_wxImageTo_p_wxObject(void *x) {
58386 return (void *)((wxObject *) ((wxImage *) x));
58387 }
58388 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58389 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58390 }
58391 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58392 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58393 }
58394 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58395 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58396 }
58397 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58398 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58399 }
58400 static void *_p_wxWindowTo_p_wxObject(void *x) {
58401 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58402 }
58403 static void *_p_wxMenuTo_p_wxObject(void *x) {
58404 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58405 }
58406 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58407 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58408 }
58409 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58410 return (void *)((wxObject *) ((wxFileSystem *) x));
58411 }
58412 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58413 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58414 }
58415 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58416 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58417 }
58418 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58419 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58420 }
58421 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58422 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58423 }
58424 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58425 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58426 }
58427 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58428 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58429 }
58430 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58431 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58432 }
58433 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58434 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58435 }
58436 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58437 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58438 }
58439 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58440 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58441 }
58442 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58444 }
58445 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58446 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58447 }
58448 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58449 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58450 }
58451 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58452 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58453 }
58454 static void *_p_wxControlTo_p_wxWindow(void *x) {
58455 return (void *)((wxWindow *) ((wxControl *) x));
58456 }
58457 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58458 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58459 }
58460 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58461 return (void *)((wxWindow *) ((wxMenuBar *) x));
58462 }
58463 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58464 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58465 }
58466 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58467 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58468 }
58469 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58470 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58471 }
58472 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58473 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58474 }
58475 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58476 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58477 }
58478 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58479 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58480 }
58481 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58482 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58483 }
58484 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58485 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58486 }
58487 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58488 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58489 }
58490 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58491 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58492 }
58493 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58494 return (void *)((wxValidator *) ((wxPyValidator *) x));
58495 }
58496 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58498 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};
58499 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58630
58631 static swig_type_info *swig_type_initial[] = {
58632 &_swigt__p_buffer,
58633 &_swigt__p_char,
58634 &_swigt__p_form_ops_t,
58635 &_swigt__p_int,
58636 &_swigt__p_long,
58637 &_swigt__p_unsigned_char,
58638 &_swigt__p_unsigned_int,
58639 &_swigt__p_unsigned_long,
58640 &_swigt__p_wxANIHandler,
58641 &_swigt__p_wxAcceleratorEntry,
58642 &_swigt__p_wxAcceleratorTable,
58643 &_swigt__p_wxActivateEvent,
58644 &_swigt__p_wxAppTraits,
58645 &_swigt__p_wxArrayString,
58646 &_swigt__p_wxBMPHandler,
58647 &_swigt__p_wxBitmap,
58648 &_swigt__p_wxBoxSizer,
58649 &_swigt__p_wxButton,
58650 &_swigt__p_wxCURHandler,
58651 &_swigt__p_wxCaret,
58652 &_swigt__p_wxChildFocusEvent,
58653 &_swigt__p_wxClipboardTextEvent,
58654 &_swigt__p_wxCloseEvent,
58655 &_swigt__p_wxColour,
58656 &_swigt__p_wxCommandEvent,
58657 &_swigt__p_wxContextMenuEvent,
58658 &_swigt__p_wxControl,
58659 &_swigt__p_wxControlWithItems,
58660 &_swigt__p_wxCursor,
58661 &_swigt__p_wxDC,
58662 &_swigt__p_wxDateEvent,
58663 &_swigt__p_wxDateTime,
58664 &_swigt__p_wxDisplayChangedEvent,
58665 &_swigt__p_wxDouble,
58666 &_swigt__p_wxDropFilesEvent,
58667 &_swigt__p_wxDuplexMode,
58668 &_swigt__p_wxEraseEvent,
58669 &_swigt__p_wxEvent,
58670 &_swigt__p_wxEventLoop,
58671 &_swigt__p_wxEventLoopActivator,
58672 &_swigt__p_wxEvtHandler,
58673 &_swigt__p_wxFSFile,
58674 &_swigt__p_wxFileSystem,
58675 &_swigt__p_wxFileSystemHandler,
58676 &_swigt__p_wxFlexGridSizer,
58677 &_swigt__p_wxFocusEvent,
58678 &_swigt__p_wxFont,
58679 &_swigt__p_wxFrame,
58680 &_swigt__p_wxGBPosition,
58681 &_swigt__p_wxGBSizerItem,
58682 &_swigt__p_wxGBSpan,
58683 &_swigt__p_wxGIFHandler,
58684 &_swigt__p_wxGridBagSizer,
58685 &_swigt__p_wxGridSizer,
58686 &_swigt__p_wxHelpEvent__Origin,
58687 &_swigt__p_wxICOHandler,
58688 &_swigt__p_wxIconizeEvent,
58689 &_swigt__p_wxIdleEvent,
58690 &_swigt__p_wxImage,
58691 &_swigt__p_wxImageHandler,
58692 &_swigt__p_wxImageHistogram,
58693 &_swigt__p_wxImage_HSVValue,
58694 &_swigt__p_wxImage_RGBValue,
58695 &_swigt__p_wxIndividualLayoutConstraint,
58696 &_swigt__p_wxInitDialogEvent,
58697 &_swigt__p_wxInputStream,
58698 &_swigt__p_wxInternetFSHandler,
58699 &_swigt__p_wxItemContainer,
58700 &_swigt__p_wxJPEGHandler,
58701 &_swigt__p_wxKeyEvent,
58702 &_swigt__p_wxLayoutConstraints,
58703 &_swigt__p_wxMaximizeEvent,
58704 &_swigt__p_wxMemoryFSHandler,
58705 &_swigt__p_wxMenu,
58706 &_swigt__p_wxMenuBar,
58707 &_swigt__p_wxMenuBarBase,
58708 &_swigt__p_wxMenuEvent,
58709 &_swigt__p_wxMenuItem,
58710 &_swigt__p_wxMouseCaptureChangedEvent,
58711 &_swigt__p_wxMouseCaptureLostEvent,
58712 &_swigt__p_wxMouseEvent,
58713 &_swigt__p_wxMoveEvent,
58714 &_swigt__p_wxNavigationKeyEvent,
58715 &_swigt__p_wxNcPaintEvent,
58716 &_swigt__p_wxNotifyEvent,
58717 &_swigt__p_wxObject,
58718 &_swigt__p_wxOutputStream,
58719 &_swigt__p_wxPCXHandler,
58720 &_swigt__p_wxPNGHandler,
58721 &_swigt__p_wxPNMHandler,
58722 &_swigt__p_wxPaintEvent,
58723 &_swigt__p_wxPaletteChangedEvent,
58724 &_swigt__p_wxPaperSize,
58725 &_swigt__p_wxPoint,
58726 &_swigt__p_wxPoint2D,
58727 &_swigt__p_wxPropagateOnce,
58728 &_swigt__p_wxPropagationDisabler,
58729 &_swigt__p_wxPyApp,
58730 &_swigt__p_wxPyCommandEvent,
58731 &_swigt__p_wxPyDropTarget,
58732 &_swigt__p_wxPyEvent,
58733 &_swigt__p_wxPyFileSystemHandler,
58734 &_swigt__p_wxPyImageHandler,
58735 &_swigt__p_wxPyInputStream,
58736 &_swigt__p_wxPySizer,
58737 &_swigt__p_wxPyValidator,
58738 &_swigt__p_wxQuantize,
58739 &_swigt__p_wxQueryNewPaletteEvent,
58740 &_swigt__p_wxRealPoint,
58741 &_swigt__p_wxRect,
58742 &_swigt__p_wxRect2D,
58743 &_swigt__p_wxRegion,
58744 &_swigt__p_wxScrollEvent,
58745 &_swigt__p_wxScrollWinEvent,
58746 &_swigt__p_wxSetCursorEvent,
58747 &_swigt__p_wxShowEvent,
58748 &_swigt__p_wxSize,
58749 &_swigt__p_wxSizeEvent,
58750 &_swigt__p_wxSizer,
58751 &_swigt__p_wxSizerItem,
58752 &_swigt__p_wxStaticBox,
58753 &_swigt__p_wxStaticBoxSizer,
58754 &_swigt__p_wxStdDialogButtonSizer,
58755 &_swigt__p_wxSysColourChangedEvent,
58756 &_swigt__p_wxTIFFHandler,
58757 &_swigt__p_wxToolTip,
58758 &_swigt__p_wxUpdateUIEvent,
58759 &_swigt__p_wxValidator,
58760 &_swigt__p_wxVisualAttributes,
58761 &_swigt__p_wxWindow,
58762 &_swigt__p_wxWindowCreateEvent,
58763 &_swigt__p_wxWindowDestroyEvent,
58764 &_swigt__p_wxXPMHandler,
58765 &_swigt__p_wxZipFSHandler,
58766 };
58767
58768 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58775 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58776 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58777 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58778 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58782 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}};
58783 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58784 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}};
58785 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58786 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}};
58787 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58792 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}};
58793 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58794 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}};
58795 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58805 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}};
58806 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58808 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}};
58809 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58811 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}};
58812 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}};
58813 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58821 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}};
58822 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58823 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}};
58824 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58827 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}};
58828 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58835 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}};
58836 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 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}};
58854 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58879 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58886 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}};
58887 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}};
58888 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58895 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}};
58896 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58897 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}};
58898 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58902
58903 static swig_cast_info *swig_cast_initial[] = {
58904 _swigc__p_buffer,
58905 _swigc__p_char,
58906 _swigc__p_form_ops_t,
58907 _swigc__p_int,
58908 _swigc__p_long,
58909 _swigc__p_unsigned_char,
58910 _swigc__p_unsigned_int,
58911 _swigc__p_unsigned_long,
58912 _swigc__p_wxANIHandler,
58913 _swigc__p_wxAcceleratorEntry,
58914 _swigc__p_wxAcceleratorTable,
58915 _swigc__p_wxActivateEvent,
58916 _swigc__p_wxAppTraits,
58917 _swigc__p_wxArrayString,
58918 _swigc__p_wxBMPHandler,
58919 _swigc__p_wxBitmap,
58920 _swigc__p_wxBoxSizer,
58921 _swigc__p_wxButton,
58922 _swigc__p_wxCURHandler,
58923 _swigc__p_wxCaret,
58924 _swigc__p_wxChildFocusEvent,
58925 _swigc__p_wxClipboardTextEvent,
58926 _swigc__p_wxCloseEvent,
58927 _swigc__p_wxColour,
58928 _swigc__p_wxCommandEvent,
58929 _swigc__p_wxContextMenuEvent,
58930 _swigc__p_wxControl,
58931 _swigc__p_wxControlWithItems,
58932 _swigc__p_wxCursor,
58933 _swigc__p_wxDC,
58934 _swigc__p_wxDateEvent,
58935 _swigc__p_wxDateTime,
58936 _swigc__p_wxDisplayChangedEvent,
58937 _swigc__p_wxDouble,
58938 _swigc__p_wxDropFilesEvent,
58939 _swigc__p_wxDuplexMode,
58940 _swigc__p_wxEraseEvent,
58941 _swigc__p_wxEvent,
58942 _swigc__p_wxEventLoop,
58943 _swigc__p_wxEventLoopActivator,
58944 _swigc__p_wxEvtHandler,
58945 _swigc__p_wxFSFile,
58946 _swigc__p_wxFileSystem,
58947 _swigc__p_wxFileSystemHandler,
58948 _swigc__p_wxFlexGridSizer,
58949 _swigc__p_wxFocusEvent,
58950 _swigc__p_wxFont,
58951 _swigc__p_wxFrame,
58952 _swigc__p_wxGBPosition,
58953 _swigc__p_wxGBSizerItem,
58954 _swigc__p_wxGBSpan,
58955 _swigc__p_wxGIFHandler,
58956 _swigc__p_wxGridBagSizer,
58957 _swigc__p_wxGridSizer,
58958 _swigc__p_wxHelpEvent__Origin,
58959 _swigc__p_wxICOHandler,
58960 _swigc__p_wxIconizeEvent,
58961 _swigc__p_wxIdleEvent,
58962 _swigc__p_wxImage,
58963 _swigc__p_wxImageHandler,
58964 _swigc__p_wxImageHistogram,
58965 _swigc__p_wxImage_HSVValue,
58966 _swigc__p_wxImage_RGBValue,
58967 _swigc__p_wxIndividualLayoutConstraint,
58968 _swigc__p_wxInitDialogEvent,
58969 _swigc__p_wxInputStream,
58970 _swigc__p_wxInternetFSHandler,
58971 _swigc__p_wxItemContainer,
58972 _swigc__p_wxJPEGHandler,
58973 _swigc__p_wxKeyEvent,
58974 _swigc__p_wxLayoutConstraints,
58975 _swigc__p_wxMaximizeEvent,
58976 _swigc__p_wxMemoryFSHandler,
58977 _swigc__p_wxMenu,
58978 _swigc__p_wxMenuBar,
58979 _swigc__p_wxMenuBarBase,
58980 _swigc__p_wxMenuEvent,
58981 _swigc__p_wxMenuItem,
58982 _swigc__p_wxMouseCaptureChangedEvent,
58983 _swigc__p_wxMouseCaptureLostEvent,
58984 _swigc__p_wxMouseEvent,
58985 _swigc__p_wxMoveEvent,
58986 _swigc__p_wxNavigationKeyEvent,
58987 _swigc__p_wxNcPaintEvent,
58988 _swigc__p_wxNotifyEvent,
58989 _swigc__p_wxObject,
58990 _swigc__p_wxOutputStream,
58991 _swigc__p_wxPCXHandler,
58992 _swigc__p_wxPNGHandler,
58993 _swigc__p_wxPNMHandler,
58994 _swigc__p_wxPaintEvent,
58995 _swigc__p_wxPaletteChangedEvent,
58996 _swigc__p_wxPaperSize,
58997 _swigc__p_wxPoint,
58998 _swigc__p_wxPoint2D,
58999 _swigc__p_wxPropagateOnce,
59000 _swigc__p_wxPropagationDisabler,
59001 _swigc__p_wxPyApp,
59002 _swigc__p_wxPyCommandEvent,
59003 _swigc__p_wxPyDropTarget,
59004 _swigc__p_wxPyEvent,
59005 _swigc__p_wxPyFileSystemHandler,
59006 _swigc__p_wxPyImageHandler,
59007 _swigc__p_wxPyInputStream,
59008 _swigc__p_wxPySizer,
59009 _swigc__p_wxPyValidator,
59010 _swigc__p_wxQuantize,
59011 _swigc__p_wxQueryNewPaletteEvent,
59012 _swigc__p_wxRealPoint,
59013 _swigc__p_wxRect,
59014 _swigc__p_wxRect2D,
59015 _swigc__p_wxRegion,
59016 _swigc__p_wxScrollEvent,
59017 _swigc__p_wxScrollWinEvent,
59018 _swigc__p_wxSetCursorEvent,
59019 _swigc__p_wxShowEvent,
59020 _swigc__p_wxSize,
59021 _swigc__p_wxSizeEvent,
59022 _swigc__p_wxSizer,
59023 _swigc__p_wxSizerItem,
59024 _swigc__p_wxStaticBox,
59025 _swigc__p_wxStaticBoxSizer,
59026 _swigc__p_wxStdDialogButtonSizer,
59027 _swigc__p_wxSysColourChangedEvent,
59028 _swigc__p_wxTIFFHandler,
59029 _swigc__p_wxToolTip,
59030 _swigc__p_wxUpdateUIEvent,
59031 _swigc__p_wxValidator,
59032 _swigc__p_wxVisualAttributes,
59033 _swigc__p_wxWindow,
59034 _swigc__p_wxWindowCreateEvent,
59035 _swigc__p_wxWindowDestroyEvent,
59036 _swigc__p_wxXPMHandler,
59037 _swigc__p_wxZipFSHandler,
59038 };
59039
59040
59041 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59042
59043 static swig_const_info swig_const_table[] = {
59044 {0, 0, 0, 0.0, 0, 0}};
59045
59046 #ifdef __cplusplus
59047 }
59048 #endif
59049 /* -----------------------------------------------------------------------------
59050 * Type initialization:
59051 * This problem is tough by the requirement that no dynamic
59052 * memory is used. Also, since swig_type_info structures store pointers to
59053 * swig_cast_info structures and swig_cast_info structures store pointers back
59054 * to swig_type_info structures, we need some lookup code at initialization.
59055 * The idea is that swig generates all the structures that are needed.
59056 * The runtime then collects these partially filled structures.
59057 * The SWIG_InitializeModule function takes these initial arrays out of
59058 * swig_module, and does all the lookup, filling in the swig_module.types
59059 * array with the correct data and linking the correct swig_cast_info
59060 * structures together.
59061 *
59062 * The generated swig_type_info structures are assigned staticly to an initial
59063 * array. We just loop though that array, and handle each type individually.
59064 * First we lookup if this type has been already loaded, and if so, use the
59065 * loaded structure instead of the generated one. Then we have to fill in the
59066 * cast linked list. The cast data is initially stored in something like a
59067 * two-dimensional array. Each row corresponds to a type (there are the same
59068 * number of rows as there are in the swig_type_initial array). Each entry in
59069 * a column is one of the swig_cast_info structures for that type.
59070 * The cast_initial array is actually an array of arrays, because each row has
59071 * a variable number of columns. So to actually build the cast linked list,
59072 * we find the array of casts associated with the type, and loop through it
59073 * adding the casts to the list. The one last trick we need to do is making
59074 * sure the type pointer in the swig_cast_info struct is correct.
59075 *
59076 * First off, we lookup the cast->type name to see if it is already loaded.
59077 * There are three cases to handle:
59078 * 1) If the cast->type has already been loaded AND the type we are adding
59079 * casting info to has not been loaded (it is in this module), THEN we
59080 * replace the cast->type pointer with the type pointer that has already
59081 * been loaded.
59082 * 2) If BOTH types (the one we are adding casting info to, and the
59083 * cast->type) are loaded, THEN the cast info has already been loaded by
59084 * the previous module so we just ignore it.
59085 * 3) Finally, if cast->type has not already been loaded, then we add that
59086 * swig_cast_info to the linked list (because the cast->type) pointer will
59087 * be correct.
59088 * ----------------------------------------------------------------------------- */
59089
59090 #ifdef __cplusplus
59091 extern "C" {
59092 #if 0
59093 } /* c-mode */
59094 #endif
59095 #endif
59096
59097 #if 0
59098 #define SWIGRUNTIME_DEBUG
59099 #endif
59100
59101 SWIGRUNTIME void
59102 SWIG_InitializeModule(void *clientdata) {
59103 size_t i;
59104 swig_module_info *module_head;
59105 static int init_run = 0;
59106
59107 clientdata = clientdata;
59108
59109 if (init_run) return;
59110 init_run = 1;
59111
59112 /* Initialize the swig_module */
59113 swig_module.type_initial = swig_type_initial;
59114 swig_module.cast_initial = swig_cast_initial;
59115
59116 /* Try and load any already created modules */
59117 module_head = SWIG_GetModule(clientdata);
59118 if (module_head) {
59119 swig_module.next = module_head->next;
59120 module_head->next = &swig_module;
59121 } else {
59122 /* This is the first module loaded */
59123 swig_module.next = &swig_module;
59124 SWIG_SetModule(clientdata, &swig_module);
59125 }
59126
59127 /* Now work on filling in swig_module.types */
59128 #ifdef SWIGRUNTIME_DEBUG
59129 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59130 #endif
59131 for (i = 0; i < swig_module.size; ++i) {
59132 swig_type_info *type = 0;
59133 swig_type_info *ret;
59134 swig_cast_info *cast;
59135
59136 #ifdef SWIGRUNTIME_DEBUG
59137 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59138 #endif
59139
59140 /* if there is another module already loaded */
59141 if (swig_module.next != &swig_module) {
59142 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59143 }
59144 if (type) {
59145 /* Overwrite clientdata field */
59146 #ifdef SWIGRUNTIME_DEBUG
59147 printf("SWIG_InitializeModule: found type %s\n", type->name);
59148 #endif
59149 if (swig_module.type_initial[i]->clientdata) {
59150 type->clientdata = swig_module.type_initial[i]->clientdata;
59151 #ifdef SWIGRUNTIME_DEBUG
59152 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59153 #endif
59154 }
59155 } else {
59156 type = swig_module.type_initial[i];
59157 }
59158
59159 /* Insert casting types */
59160 cast = swig_module.cast_initial[i];
59161 while (cast->type) {
59162 /* Don't need to add information already in the list */
59163 ret = 0;
59164 #ifdef SWIGRUNTIME_DEBUG
59165 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59166 #endif
59167 if (swig_module.next != &swig_module) {
59168 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59169 #ifdef SWIGRUNTIME_DEBUG
59170 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59171 #endif
59172 }
59173 if (ret) {
59174 if (type == swig_module.type_initial[i]) {
59175 #ifdef SWIGRUNTIME_DEBUG
59176 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59177 #endif
59178 cast->type = ret;
59179 ret = 0;
59180 } else {
59181 /* Check for casting already in the list */
59182 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59183 #ifdef SWIGRUNTIME_DEBUG
59184 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59185 #endif
59186 if (!ocast) ret = 0;
59187 }
59188 }
59189
59190 if (!ret) {
59191 #ifdef SWIGRUNTIME_DEBUG
59192 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59193 #endif
59194 if (type->cast) {
59195 type->cast->prev = cast;
59196 cast->next = type->cast;
59197 }
59198 type->cast = cast;
59199 }
59200 cast++;
59201 }
59202 /* Set entry in modules->types array equal to the type */
59203 swig_module.types[i] = type;
59204 }
59205 swig_module.types[i] = 0;
59206
59207 #ifdef SWIGRUNTIME_DEBUG
59208 printf("**** SWIG_InitializeModule: Cast List ******\n");
59209 for (i = 0; i < swig_module.size; ++i) {
59210 int j = 0;
59211 swig_cast_info *cast = swig_module.cast_initial[i];
59212 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59213 while (cast->type) {
59214 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59215 cast++;
59216 ++j;
59217 }
59218 printf("---- Total casts: %d\n",j);
59219 }
59220 printf("**** SWIG_InitializeModule: Cast List ******\n");
59221 #endif
59222 }
59223
59224 /* This function will propagate the clientdata field of type to
59225 * any new swig_type_info structures that have been added into the list
59226 * of equivalent types. It is like calling
59227 * SWIG_TypeClientData(type, clientdata) a second time.
59228 */
59229 SWIGRUNTIME void
59230 SWIG_PropagateClientData(void) {
59231 size_t i;
59232 swig_cast_info *equiv;
59233 static int init_run = 0;
59234
59235 if (init_run) return;
59236 init_run = 1;
59237
59238 for (i = 0; i < swig_module.size; i++) {
59239 if (swig_module.types[i]->clientdata) {
59240 equiv = swig_module.types[i]->cast;
59241 while (equiv) {
59242 if (!equiv->converter) {
59243 if (equiv->type && !equiv->type->clientdata)
59244 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59245 }
59246 equiv = equiv->next;
59247 }
59248 }
59249 }
59250 }
59251
59252 #ifdef __cplusplus
59253 #if 0
59254 {
59255 /* c-mode */
59256 #endif
59257 }
59258 #endif
59259
59260
59261
59262 #ifdef __cplusplus
59263 extern "C" {
59264 #endif
59265
59266 /* Python-specific SWIG API */
59267 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59268 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59269 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59270
59271 /* -----------------------------------------------------------------------------
59272 * global variable support code.
59273 * ----------------------------------------------------------------------------- */
59274
59275 typedef struct swig_globalvar {
59276 char *name; /* Name of global variable */
59277 PyObject *(*get_attr)(void); /* Return the current value */
59278 int (*set_attr)(PyObject *); /* Set the value */
59279 struct swig_globalvar *next;
59280 } swig_globalvar;
59281
59282 typedef struct swig_varlinkobject {
59283 PyObject_HEAD
59284 swig_globalvar *vars;
59285 } swig_varlinkobject;
59286
59287 SWIGINTERN PyObject *
59288 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59289 return PyString_FromString("<Swig global variables>");
59290 }
59291
59292 SWIGINTERN PyObject *
59293 swig_varlink_str(swig_varlinkobject *v) {
59294 PyObject *str = PyString_FromString("(");
59295 swig_globalvar *var;
59296 for (var = v->vars; var; var=var->next) {
59297 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59298 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59299 }
59300 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59301 return str;
59302 }
59303
59304 SWIGINTERN int
59305 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59306 PyObject *str = swig_varlink_str(v);
59307 fprintf(fp,"Swig global variables ");
59308 fprintf(fp,"%s\n", PyString_AsString(str));
59309 Py_DECREF(str);
59310 return 0;
59311 }
59312
59313 SWIGINTERN void
59314 swig_varlink_dealloc(swig_varlinkobject *v) {
59315 swig_globalvar *var = v->vars;
59316 while (var) {
59317 swig_globalvar *n = var->next;
59318 free(var->name);
59319 free(var);
59320 var = n;
59321 }
59322 }
59323
59324 SWIGINTERN PyObject *
59325 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59326 PyObject *res = NULL;
59327 swig_globalvar *var = v->vars;
59328 while (var) {
59329 if (strcmp(var->name,n) == 0) {
59330 res = (*var->get_attr)();
59331 break;
59332 }
59333 var = var->next;
59334 }
59335 if (res == NULL && !PyErr_Occurred()) {
59336 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59337 }
59338 return res;
59339 }
59340
59341 SWIGINTERN int
59342 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59343 int res = 1;
59344 swig_globalvar *var = v->vars;
59345 while (var) {
59346 if (strcmp(var->name,n) == 0) {
59347 res = (*var->set_attr)(p);
59348 break;
59349 }
59350 var = var->next;
59351 }
59352 if (res == 1 && !PyErr_Occurred()) {
59353 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59354 }
59355 return res;
59356 }
59357
59358 SWIGINTERN PyTypeObject*
59359 swig_varlink_type(void) {
59360 static char varlink__doc__[] = "Swig var link object";
59361 static PyTypeObject varlink_type;
59362 static int type_init = 0;
59363 if (!type_init) {
59364 const PyTypeObject tmp
59365 = {
59366 PyObject_HEAD_INIT(NULL)
59367 0, /* Number of items in variable part (ob_size) */
59368 (char *)"swigvarlink", /* Type name (tp_name) */
59369 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59370 0, /* Itemsize (tp_itemsize) */
59371 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59372 (printfunc) swig_varlink_print, /* Print (tp_print) */
59373 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59374 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59375 0, /* tp_compare */
59376 (reprfunc) swig_varlink_repr, /* tp_repr */
59377 0, /* tp_as_number */
59378 0, /* tp_as_sequence */
59379 0, /* tp_as_mapping */
59380 0, /* tp_hash */
59381 0, /* tp_call */
59382 (reprfunc)swig_varlink_str, /* tp_str */
59383 0, /* tp_getattro */
59384 0, /* tp_setattro */
59385 0, /* tp_as_buffer */
59386 0, /* tp_flags */
59387 varlink__doc__, /* tp_doc */
59388 0, /* tp_traverse */
59389 0, /* tp_clear */
59390 0, /* tp_richcompare */
59391 0, /* tp_weaklistoffset */
59392 #if PY_VERSION_HEX >= 0x02020000
59393 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59394 #endif
59395 #if PY_VERSION_HEX >= 0x02030000
59396 0, /* tp_del */
59397 #endif
59398 #ifdef COUNT_ALLOCS
59399 0,0,0,0 /* tp_alloc -> tp_next */
59400 #endif
59401 };
59402 varlink_type = tmp;
59403 varlink_type.ob_type = &PyType_Type;
59404 type_init = 1;
59405 }
59406 return &varlink_type;
59407 }
59408
59409 /* Create a variable linking object for use later */
59410 SWIGINTERN PyObject *
59411 SWIG_Python_newvarlink(void) {
59412 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59413 if (result) {
59414 result->vars = 0;
59415 }
59416 return ((PyObject*) result);
59417 }
59418
59419 SWIGINTERN void
59420 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59421 swig_varlinkobject *v = (swig_varlinkobject *) p;
59422 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59423 if (gv) {
59424 size_t size = strlen(name)+1;
59425 gv->name = (char *)malloc(size);
59426 if (gv->name) {
59427 strncpy(gv->name,name,size);
59428 gv->get_attr = get_attr;
59429 gv->set_attr = set_attr;
59430 gv->next = v->vars;
59431 }
59432 }
59433 v->vars = gv;
59434 }
59435
59436 SWIGINTERN PyObject *
59437 SWIG_globals() {
59438 static PyObject *_SWIG_globals = 0;
59439 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59440 return _SWIG_globals;
59441 }
59442
59443 /* -----------------------------------------------------------------------------
59444 * constants/methods manipulation
59445 * ----------------------------------------------------------------------------- */
59446
59447 /* Install Constants */
59448 SWIGINTERN void
59449 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59450 PyObject *obj = 0;
59451 size_t i;
59452 for (i = 0; constants[i].type; ++i) {
59453 switch(constants[i].type) {
59454 case SWIG_PY_POINTER:
59455 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59456 break;
59457 case SWIG_PY_BINARY:
59458 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59459 break;
59460 default:
59461 obj = 0;
59462 break;
59463 }
59464 if (obj) {
59465 PyDict_SetItemString(d, constants[i].name, obj);
59466 Py_DECREF(obj);
59467 }
59468 }
59469 }
59470
59471 /* -----------------------------------------------------------------------------*/
59472 /* Fix SwigMethods to carry the callback ptrs when needed */
59473 /* -----------------------------------------------------------------------------*/
59474
59475 SWIGINTERN void
59476 SWIG_Python_FixMethods(PyMethodDef *methods,
59477 swig_const_info *const_table,
59478 swig_type_info **types,
59479 swig_type_info **types_initial) {
59480 size_t i;
59481 for (i = 0; methods[i].ml_name; ++i) {
59482 const char *c = methods[i].ml_doc;
59483 if (c && (c = strstr(c, "swig_ptr: "))) {
59484 int j;
59485 swig_const_info *ci = 0;
59486 const char *name = c + 10;
59487 for (j = 0; const_table[j].type; ++j) {
59488 if (strncmp(const_table[j].name, name,
59489 strlen(const_table[j].name)) == 0) {
59490 ci = &(const_table[j]);
59491 break;
59492 }
59493 }
59494 if (ci) {
59495 size_t shift = (ci->ptype) - types;
59496 swig_type_info *ty = types_initial[shift];
59497 size_t ldoc = (c - methods[i].ml_doc);
59498 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59499 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59500 if (ndoc) {
59501 char *buff = ndoc;
59502 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59503 if (ptr) {
59504 strncpy(buff, methods[i].ml_doc, ldoc);
59505 buff += ldoc;
59506 strncpy(buff, "swig_ptr: ", 10);
59507 buff += 10;
59508 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59509 methods[i].ml_doc = ndoc;
59510 }
59511 }
59512 }
59513 }
59514 }
59515 }
59516
59517 #ifdef __cplusplus
59518 }
59519 #endif
59520
59521 /* -----------------------------------------------------------------------------*
59522 * Partial Init method
59523 * -----------------------------------------------------------------------------*/
59524
59525 #ifdef __cplusplus
59526 extern "C"
59527 #endif
59528 SWIGEXPORT void SWIG_init(void) {
59529 PyObject *m, *d;
59530
59531 /* Fix SwigMethods to carry the callback ptrs when needed */
59532 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59533
59534 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59535 d = PyModule_GetDict(m);
59536
59537 SWIG_InitializeModule(0);
59538 SWIG_InstallConstants(d,swig_const_table);
59539
59540
59541
59542 #ifndef wxPyUSE_EXPORT
59543 // Make our API structure a CObject so other modules can import it
59544 // from this module.
59545 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59546 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59547 Py_XDECREF(cobj);
59548 #endif
59549
59550 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59551 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59552 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59553 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59554 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59555 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59556 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59557 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59558 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59559 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59560 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59561 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59562 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59563 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59564 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59565 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59566 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59567 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59568 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59569 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59570 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59571 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59572 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59573 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59574 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59575 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59576 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59577 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59578 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59579 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59580 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59581 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59582 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59583 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59584 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59585 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59586 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59587 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59588 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59589 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59590 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59591 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59592 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59593 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59594 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59595 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59596 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59597 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59598 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59599 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59600 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59601 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59602 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59603 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59604 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59605 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59606 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59607 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59608 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59609 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59610 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59611 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59612 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59613 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59614 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59615 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59616 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59617 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59618 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59619 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59620 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59621 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59622 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59623 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59624 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59625 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59626 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59627 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59628 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59629 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59630 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59631 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59632 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59633 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59634 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59635 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59636 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59637 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59638 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59639 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59640 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59641 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59642 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59643 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59644 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59645 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59646 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59647 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59648 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59649 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59650 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59651 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59652 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59653 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59654 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59655 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59656 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59657 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59658 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59659 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59660 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59661 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59662 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59663 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59664 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59665 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59666 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59667 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59668 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59669 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59670 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59671 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59672 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59673 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59674 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59675 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59676 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59677 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59678 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59679 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59680 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59681 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59682 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59683 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59684 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59685 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59686 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59687 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59688 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59689 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59690 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59691 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59692 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59693 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59694 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59695 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59696 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59697 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59698 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59699 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59700 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59701 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59702 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59703 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59704 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59705 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59706 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59707 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59708 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59709 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59710 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59711 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59712 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59713 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59714 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59715 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59716 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59717 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59718 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59719 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59720 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59721 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59722 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59723 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59724 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59725 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59726 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59727 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59728 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59729 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59730 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59731 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59732 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59733 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59734 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59735 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59736 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59737 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59738 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59739 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59740 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59741 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59742 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59743 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59744 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59745 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59746 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59747 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59748 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59749 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59750 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59751 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59752 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59753 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59754 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59755 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59756 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59757 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59758 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59759 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59760 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59761 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59762 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59763 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59764 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59765 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59766 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59767 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59768 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59769 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59770 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59771 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59772 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59773 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59774 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59775 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59776 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59777 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59778 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59779 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59780 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59781 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59782 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59783 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59784 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59785 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59786 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59787 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59788 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59789 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59790 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59791 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59792 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59793 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59794 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59795 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59796 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59797 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59798 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59799 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59800 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59801 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59802 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59803 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59804 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59805 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59806 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59807 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59808 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59809 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59810 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59811 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59812 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59813 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59814 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59815 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59816 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59817 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59818 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59819 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59820 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59821 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59822 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59823 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59824 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59825 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59826 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59827 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59828 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59829 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59830 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59831 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59832 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59833 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59834 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59835 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59836 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59837 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59838 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59839 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59840 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59841 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59842 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59843 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59844 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59845 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59846 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59847 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59848 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59849 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59850 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59851 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59852 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59853 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59854 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59855 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59856 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59857 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59858 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59859 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59860 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59861 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59862 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59863 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59864 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59865 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59866 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59867 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59868 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59869 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59870 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59871 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59872 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59873 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59874 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59875 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59876 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59877 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59878 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59879 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59880 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59881 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59882 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59883 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59884 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59885 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59886 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59887 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59888 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59889 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59890 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59891 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59892 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59893 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59894 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59895 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59896 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59897 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59898 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59899 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59910 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59911 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59912 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59913 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59914 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59915 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59916 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59917 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59918 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59919 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59920 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59921 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59922 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59923 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59924 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59925 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59926 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59927 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59928 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59929 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59930 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59931 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59932 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59933 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59934 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59935 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59936 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59937 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59938 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59939 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59940 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59941 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59942 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59943 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59944 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59945 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59946 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59947 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59948 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59949 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59951 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59952 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59956 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59957 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59958 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59959 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59971 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59972 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59973 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59974 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59975 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59976 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59977 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59978 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59979 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59980 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59981 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59982 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59983 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59984 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59985 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59986 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59987 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59988 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59989 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59990 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59991 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59992 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59993 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59994 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59995 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59996 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59997 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59998 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59999 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60000 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60001 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60002 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60003 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60004 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60005 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60006 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60007 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60008 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60009 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60010 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60011 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60012 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60013 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60014 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60015 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60016 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60017 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60018 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60019 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60020 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60021 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60022 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60023 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60024 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60025 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60026 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60027 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60028 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60029 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60030 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60031 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60032 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60033 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60034 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60035 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60036 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60037 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60038 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60039 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60040 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60041 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60042 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60043 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60044 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60045 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60046 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60047 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60048 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60049 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60050 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60051 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60052 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60053 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60054 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60055 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60056 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60057 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60058 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60059 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60060 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60061 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60062 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60063 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60064 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60065 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60066 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60067 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60068 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60069 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60070 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60071 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60072 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60073 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60074 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60075 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60076 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60077 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60078 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60079 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60080 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60081 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60082 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60083 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60084 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60085 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60086 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60087 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60088 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60089 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60090 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60091 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60092 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60093 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60094 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60095 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60096 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60097 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60098 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60099 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60100 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60101 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60102 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60103 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60104 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60105 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60106 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60107 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60108 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60109 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60110 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60111 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60112 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60113 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60114 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60115 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60116 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60117 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60118 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60119 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60120 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60121 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60122 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60123 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60124 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60125 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60126 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60127 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60128 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60129 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60130 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60131 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60132 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60133 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60134 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60135 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60136 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60137 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60138 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60139 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60140 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60141 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60142 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60143 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60144 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60145 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60146 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60147 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60148 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60149 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60150 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60151 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60152 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60153 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60154 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60155 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60156 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60157 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60158 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60159 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60160 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60161 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60162 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60163 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60164 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60165 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60166 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60174 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60175 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60176 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60177 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60178 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60179 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60180 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60181 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60182 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60183 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60184 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60185 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60186 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60187 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60188 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60189 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60190 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60191 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60192 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60193 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60194 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60195 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60196 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60197 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60198 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60199 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60200 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60201 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60202 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60203 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60204 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60205 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60206 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60207 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60208 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60209 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60210 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60211 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60212 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60213 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60214 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60215
60216 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60217
60218
60219 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60220
60221 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60222 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60223 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60224 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60225 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60226 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60227 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60228 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60229 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60230 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60231 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60232 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60233 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60234 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60235 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60236 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60237 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60238 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60239 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60240 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60241 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60242 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60243 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60244 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60245 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60246 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60247 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60248 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60249 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60250 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60251 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60252 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60253 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60254 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60255 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60256 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60257 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60258 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60259 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60260 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60261 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60262 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60263 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60264 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60265 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60266 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60267 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60268 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60269 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60270 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60271 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60272 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60273 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60274 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60275 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60276 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60277 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60278 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60279 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60280 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60281 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60282 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60283 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60284 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60285 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60286 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60287 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60288 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60289 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60290 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60291 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60292 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60293 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60294 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60295 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60296 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60297 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60298 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60299 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60300 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60301 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60302 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60303 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60304 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60305 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60306 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60307 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60308 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60309 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60310 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60311 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60312 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60313 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60314 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60315 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60316 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60317 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60318 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60319 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60320 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60321 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60322 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60323 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60324 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60325 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60326 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60327 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60328 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60329 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60330 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60331 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60332 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60333 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60334 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60335 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60336 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60337 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60338 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60339 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60340 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60341 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60342 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60343 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60344 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60345 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60346 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60347 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60348 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60349 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60350 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60351 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60352 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60353 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60354 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60355 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60356 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60357 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60358 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60359 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60360 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60361 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60362 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60363 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60364 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60365 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60366 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60367 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60368 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60369 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60370 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60371 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60372 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60373 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60374 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60375 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60376 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60377 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60378 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60379 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60380 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60381 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60382 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60383 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60384 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60385 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60386 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60387 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60388 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60389 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60390 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60391 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60392 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60393 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60394 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60395 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60396 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60397 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60398 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60399 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60400 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60401 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60402 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60403 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60404 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60405 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60406 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60407 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60408 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60409 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60410 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60411 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60412 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60413 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60414 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60415 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60416 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60417 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60418 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60419 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60420 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60421 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60422 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60423 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60424 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60425 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60426 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60427 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60428 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60429 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60430 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60431 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60432 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60433 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60434 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60435
60436 // Initialize threading, some globals and such
60437 __wxPyPreStart(d);
60438
60439
60440 // Although these are defined in __version__ they need to be here too so
60441 // that an assert can be done to ensure that the wxPython and the wxWindows
60442 // versions match.
60443 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60444 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60445 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60446
60447 }
60448
wxWidgets (Impactor)